Source Code for Module xformslib.library

    1  #!/usr/bin/env python 
    2  # -*- coding: iso8859-1 -*- 
    3   
    4  """ 
    5      xforms-python 
    6      Python wrapper for XForms (X11) GUI C toolkit library using ctypes 
    7   
    8      Copyright (C) 2009  Luca Lazzaroni "LukenShiro"  <lukenshiro@ngi.it> 
    9   
   10      This program is free software: you can redistribute it and/or modify 
   11      it under the terms of the GNU Lesser General Public License as 
   12      published by the Free Software Foundation, version 2.1 of the License. 
   13   
   14      This program is distributed in the hope that it will be useful, 
   15      but WITHOUT ANY WARRANTY; without even the implied warranty of 
   16      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
   17      GNU Lesser General Public License for more details. 
   18   
   19      You should have received a copy of the GNU LGPL along with this 
   20      program. If not, see <http://www.gnu.org/licenses/>. 
   21   
   22      See CREDITS file to read acknowledgements and thanks to XForms, 
   23      ctypes and other developers. 
   24  """ 
   25   
   26  # originally generated by 'h2xml+gccxml' and 'xml2py' 
   27  # then heavily reordered and reworked 
   28   
   29  # ############################################# # 
   30  # Interface to XForms shared object libraries   # 
   31  # ############################################# # 
   32   
   33  import ctypes as cty 
   34  import ctypes.util as ctyutil 
   35  import sys 
   36  import warnings 
   37  from xfdata import *       # data types and constants from XForms 
   38   
   39   
   40  # xforms-python version 
   41  __mainversion__ = "0.3.1"               # real version 
   42  __vers_against_xforms__ = "1.0.93pre2"   # xforms version to be built against 
   43  __version__ = __mainversion__+"_"+__vers_against_xforms__ 
   44   
   45   
   46  header_filename = "/usr/include/forms.h" 
   47   
   48   
   49 -def get_xforms_version(): 
   50      """ Return version string of installed XForms library/header 
   51      """ 
   52   
   53      complete_xf_version = "" 
   54      try: 
   55          formsh = open(header_filename, "r") 
   56      except IOError: 
   57          raise XFormsLoadError("XForms library toolkit header is not " \ 
   58                                " installed properly") 
   59      else: 
   60          try: 
   61              # a reasonable size to catch version values 
   62              fconten = formsh.read(2500) 
   63          except IOError: 
   64              raise XFormsLoadError("XForms library toolkit header is not " \ 
   65                                    "installed properly") 
   66          else: 
   67              formsh.close() 
   68              listconten = fconten.split("\n") 
   69              for singline in listconten: 
   70                  idx_ver = singline.find("FL_VERSION") 
   71                  if idx_ver != -1: 
   72                      strg_ver1 = singline[idx_ver:len(singline)] 
   73                      strg_ver = strg_ver1.replace("FL_VERSION", "").strip(" ") 
   74                      break 
   75              for singline in listconten: 
   76                  idx_rev = singline.find("FL_REVISION") 
   77                  if idx_rev != -1: 
   78                      strg_rev1 = singline[idx_rev:len(singline)] 
   79                      strg_rev = strg_rev1.replace("FL_REVISION", "").strip(" ") 
   80                      break 
   81              for singline in listconten: 
   82                  idx_fix = singline.find("FL_FIXLEVEL") 
   83                  if idx_fix != -1: 
   84                      strg_fix1 = singline[idx_fix:len(singline)] 
   85                      strg_fix = strg_fix1.replace("FL_FIXLEVEL", \ 
   86                                                   "").strip(" ").strip('"') 
   87                      break 
   88              complete_xf_version = strg_ver+"."+strg_rev+"."+strg_fix 
   89   
   90      return complete_xf_version 
   91   
   92   
   93 -def verify_version_compatibility(): 
   94      """ verify compatibility between xforms-python version and XForms version 
   95      """ 
   96   
   97      xforms_vers = get_xforms_version() 
   98      if __vers_against_xforms__ != xforms_vers:      # no match 
   99          warningmsg = "xforms-python is implemented against XForms version " \ 
  100                      " %s and does not match XForms installed version " \ 
  101                      "(%s). Some compatibility problems may arise if XForms" \ 
  102                      " public interface has been modified." % \ 
  103                      (__vers_against_xforms__, xforms_vers) 
  104          warnings.warn(warningmsg, UserWarning) 
  105   
  106   
  107 -class XFormsLoadError(OSError): 
  108      """ Error in loading shared object library """ 
  109   
  110      pass 
  111   
  112   
  113 -class XFormsTypeError(TypeError): 
  114      """ Generic error for type mismatch """ 
  115   
  116      pass 
  117   
  118   
  119 -def warn_deprecated_function(altfunc=""): 
  120      """ Warns the user when a function is deprecated and should not be used 
  121          anymore. If a param is provided it may advide the user about an 
  122          alternative function. 
  123      """ 
  124   
  125      funcname = sys._getframe(1).f_code.co_name 
  126      if altfunc: 
  127          newaltfunc = "Use %s instead." % altfunc 
  128      else: 
  129          newaltfunc = "" 
  130      warningmsg = "Function %s is deprecated and might be removed in future" \ 
  131                    " releases. %s" % (funcname, newaltfunc) 
  132      warnings.warn(warningmsg, DeprecationWarning, 3) 
  133   
  134   
  135 -def func_do_nothing_placeholder(cfunction): 
  136      """ Print a warning if called function doesn't exist 
  137      """ 
  138   
  139      warningmsg = "C function %s does NOT exist, hence its call is ignored," \ 
  140                   " hence it is not wrappable and callable in python, as " \ 
  141                   "well. Maybe removed or disabled?" % cfunction 
  142      warnings.warn(warningmsg, UserWarning) 
  143      return None 
  144   
  145   
  146  # placeholders to keep reference to c functions 
  147  # keeps global to avoid garbage collector's' unpredictable behaviour 
  148  _cfunc_refs = [] 
  149  # just in case, maintains elements used as parameters, too 
  150  _elem_refs = [] 
  151   
  152   
  153 -def keep_cfunc_refs(*cfunclist): 
  154      """ Adds a reference for _cfunc_refs list of values 
  155      """ 
  156   
  157      for singvalue in cfunclist: 
  158          _cfunc_refs.append(singvalue) 
  159   
  160   
  161 -def keep_elem_refs(*elemlist): 
  162      """ Adds a reference for _elem_refs list of values 
  163      """ 
  164   
  165      for singvalue in elemlist: 
  166          _elem_refs.append(singvalue) 
  167   
  168   
  169  loaded_xlibraries = {'libforms' : None, 'libflimage' : None, \ 
  170                      'libformsgl' : None, 'libx11' : None} 
  171   
  172   
  173 -def load_so_libforms(): 
  174      """ Load libforms.so else raise an error -> library instance 
  175      """ 
  176   
  177      if loaded_xlibraries['libforms'] is None: 
  178          libfbase = ctyutil.find_library("forms") 
  179          if not libfbase:    # not installed 
  180              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  181                                    " properly") 
  182          else: 
  183              loaded_xlibraries['libforms'] = cty.cdll.LoadLibrary(libfbase) 
  184      return loaded_xlibraries['libforms'] 
  185   
  186   
  187 -def load_so_libflimage(): 
  188      """ Load libflimage.so else raise an error -> library instance 
  189      """ 
  190   
  191      if loaded_xlibraries['libflimage'] is None: 
  192          libfimg = ctyutil.find_library("flimage") 
  193          if not libfimg:    # not installed 
  194              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  195                                    " properly") 
  196          else: 
  197              loaded_xlibraries['libflimage'] = cty.cdll.LoadLibrary(libfimg) 
  198      return loaded_xlibraries['libflimage'] 
  199   
  200   
  201 -def load_so_libformsgl(): 
  202      """ Load libformsGL.so else raise an error -> library instance 
  203      """ 
  204   
  205      if loaded_xlibraries['libformsgl'] is None: 
  206          libfgl = ctyutil.find_library("formsGL") 
  207          if not libfgl:    # not installed 
  208              raise XFormsLoadError("XForms library toolkit is not installed" \ 
  209                                    " properly, with OpenGL support") 
  210          else: 
  211              loaded_xlibraries['libformsgl'] = cty.cdll.LoadLibrary(libfgl) 
  212      return loaded_xlibraries['libformsgl'] 
  213   
  214   
  215 -def load_so_libx11(): 
  216      """ Load libX11.so.6 else raise an error -> library instance 
  217      """ 
  218   
  219      if loaded_xlibraries['libx11'] is None: 
  220          libx11 = ctyutil.find_library("X11") 
  221          if not libx11:    # not installed 
  222              raise XFormsLoadError("X11 libraries are not installed" \ 
  223                                    " properly") 
  224          else: 
  225              loaded_xlibraries['libx11'] = cty.cdll.LoadLibrary(libx11) 
  226      return loaded_xlibraries['libx11'] 
  227   
  228   
  229 -def cfuncproto(library, cfuncname, retval, arglist, doc=""): 
  230      """ Prototype for C function to be wrapped in python 
  231      """ 
  232   
  233      loadedfunc = None 
  234      try: 
  235          loadedfunc = getattr(library, cfuncname) 
  236      except AttributeError: 
  237          # function doesn't exist 
  238          loadedfunc = func_do_nothing_placeholder(cfuncname) 
  239      else: 
  240          loadedfunc.restype = retval 
  241          loadedfunc.argtypes = arglist 
  242          loadedfunc.__doc__ = doc 
  243   
  244      return loadedfunc 
  245   
  246   
  247  # functions to convert a parameter into a python type then into the 
  248  # equivalent ctypes type 
  249   
  250 -def convert_to_string(paramname): 
  251      """ Converts paramname to python str and to ctypes c_char_p """ 
  252   
  253      try: 
  254          retv0 = str(paramname) 
  255      except ValueError: 
  256          raise XFormsTypeError("Parameter cannot be converted into" \ 
  257                                "'str'/'c_char_p'") 
  258      retv = cty.c_char_p(retv0) 
  259      #print "string", paramname, retv0, retv 
  260      return retv 
  261   
  262   
  263 -def convert_to_int(paramname): 
  264      """ Converts paramname to python int and to ctypes c_int """ 
  265   
  266      if not isinstance(paramname, cty.c_int): 
  267          try: 
  268              retv0 = int(paramname) 
  269          except ValueError: 
  270              raise XFormsTypeError("Parameter cannot be converted into" \ 
  271                                    " 'int'/'c_int'") 
  272          retv = cty.c_int(retv0) 
  273          #print "int", paramname, retv0, retv 
  274          return retv 
  275      else: 
  276          return paramname 
  277   
  278  convert_to_FL_Coord = convert_to_int 
  279   
  280   
  281 -def convert_to_uint(paramname): 
  282      """ Converts paramname to python int and to ctypes c_uint """ 
  283   
  284      if not isinstance(paramname, cty.c_int): 
  285          try: 
  286              retv0 = int(paramname) 
  287          except ValueError: 
  288              raise XFormsTypeError("Parameter cannot be converted into" \ 
  289                                    " 'int'/'c_uint'") 
  290          else: 
  291              retv = cty.c_uint(retv0) 
  292              #print "uint", paramname, retv0, retv 
  293              return retv 
  294      else: 
  295          return paramname 
  296   
  297   
  298 -def convert_to_long(paramname): 
  299      """ Converts paramname to python long and to ctypes c_long """ 
  300   
  301      if not isinstance(paramname, cty.c_long): 
  302          try: 
  303              retv0 = long(paramname) 
  304          except ValueError: 
  305              raise XFormsTypeError("Parameter cannot be converted into" \ 
  306                                    " 'long'/'c_long'") 
  307          else: 
  308              retv = cty.c_long(retv0) 
  309              #print "long", paramname, retv0, retv 
  310              return retv 
  311      else: 
  312          return paramname 
  313   
  314   
  315 -def convert_to_ulong(paramname): 
  316      """ Converts paramname to python long and to ctypes c_ulong """ 
  317   
  318      if not isinstance(paramname, cty.c_ulong): 
  319          try: 
  320              retv0 = long(paramname) 
  321          except ValueError: 
  322              raise XFormsTypeError("Parameter cannot be converted into" \ 
  323                                " 'long'/'c_ulong'") 
  324          else: 
  325              retv = cty.c_ulong(retv0) 
  326              #print "ulong", paramname, retv0, retv 
  327              return retv 
  328      else: 
  329          return paramname 
  330   
  331   
  332  convert_to_FL_COLOR = convert_to_ulong 
  333  convert_to_Window = convert_to_ulong 
  334  convert_to_Pixmap = convert_to_ulong 
  335   
  336   
  337 -def convert_to_double(paramname): 
  338      """ Converts paramname to python float and to ctypes c_double """ 
  339   
  340      if not isinstance(paramname, cty.c_double): 
  341          try: 
  342              retv0 = float(paramname) 
  343          except ValueError: 
  344              raise XFormsTypeError("Parameter cannot be converted into" \ 
  345                                    " 'float'/'c_double'") 
  346          else: 
  347              retv = cty.c_double(retv0) 
  348              #print "double", paramname, retv0, retv 
  349              return retv 
  350      else: 
  351          return paramname 
  352   
  353   
  354 -def convert_to_float(paramname): 
  355      """ Converts paramname to python float and to ctypes c_float """ 
  356   
  357      if not isinstance(paramname, cty.c_float): 
  358          try: 
  359              retv0 = float(paramname) 
  360          except ValueError: 
  361              raise XFormsTypeError("Parameter cannot be converted into" \ 
  362                                    " 'float'/'c_float'") 
  363          else: 
  364              retv = cty.c_float(retv0) 
  365              #print "float", paramname, retv0, retv 
  366              return retv 
  367      else: 
  368          return paramname 
  369   
  370   
  371 -def convert_to_ubyte(paramname): 
  372      """ Converts paramname to ctypes c_ubyte """ 
  373   
  374      retv = cty.c_ubyte(paramname) 
  375      return retv 
  376   
  377   
  378 -def make_int_and_pointer(): 
  379      """ Makes a ctypes c_int and its pointer, and returns both """ 
  380   
  381      baseval = cty.c_int() 
  382      ptrbaseval = cty.byref(baseval) 
  383      return baseval, ptrbaseval 
  384   
  385  make_FL_Coord_and_pointer = make_int_and_pointer 
  386   
  387   
  388 -def make_uint_and_pointer(): 
  389      """ Makes a ctypes c_uint and its pointer, and returns both """ 
  390   
  391      baseval = cty.c_uint() 
  392      ptrbaseval = cty.byref(baseval) 
  393      return baseval, ptrbaseval 
  394   
  395   
  396 -def make_long_and_pointer(): 
  397      """ Makes a ctypes c_long and its pointer, and returns both """ 
  398   
  399      baseval = cty.c_long() 
  400      ptrbaseval = cty.byref(baseval) 
  401      return baseval, ptrbaseval 
  402   
  403   
  404 -def make_ulong_and_pointer(): 
  405      """ Makes a ctypes c_ulong and its pointer, and returns both """ 
  406   
  407      baseval = cty.c_ulong() 
  408      ptrbaseval = cty.byref(baseval) 
  409      return baseval, ptrbaseval 
  410   
  411  make_Pixmap_and_pointer = make_ulong_and_pointer 
  412  make_FL_COLOR_and_pointer = make_ulong_and_pointer 
  413   
  414   
  415 -def make_float_and_pointer(): 
  416      """ Makes a ctypes c_float and its pointer, and returns both """ 
  417   
  418      baseval = cty.c_float() 
  419      ptrbaseval = cty.byref(baseval) 
  420      return baseval, ptrbaseval 
  421   
  422   
  423 -def make_double_and_pointer(): 
  424      """ Makes a ctypes c_double and its pointer, and returns both """ 
  425   
  426      baseval = cty.c_double() 
  427      ptrbaseval = cty.byref(baseval) 
  428      return baseval, ptrbaseval 
  429   
  430   
  431 -def check_admitted_listvalues(paramname, *valueslist): 
  432      """ Check if paramname value is valid in accordance to a list 
  433          of admissible values. 
  434      """ 
  435   
  436      if isinstance(valueslist, list): 
  437          if paramname not in valueslist: 
  438              raise XFormsTypeError("Parameter value must be included in " \ 
  439                                    "list %s." % valueslist) 
  440   
  441   
  442  # exported variables 
  443  FL_EVENT = (cty.POINTER(FL_OBJECT)).in_dll(load_so_libforms(), 'FL_EVENT') 
  444  fl_current_form = (cty.POINTER(FL_FORM)).in_dll(load_so_libforms(), \ 
  445                    'fl_current_form') 
  446  fl_display = (cty.POINTER(Display)).in_dll(load_so_libforms(), 'fl_display') 
  447  fl_screen = (cty.c_int).in_dll(load_so_libforms(), 'fl_screen') 
  448  # root window 
  449  fl_root = (Window).in_dll(load_so_libforms(), 'fl_root') 
  450  # virtual root window 
  451  fl_vroot = (Window).in_dll(load_so_libforms(), 'fl_vroot') 
  452  # screen dimension in pixels 
  453  fl_scrh = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrh') 
  454  fl_scrw = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrw') 
  455  fl_vmode = (cty.c_int).in_dll(load_so_libforms(), 'fl_vmode') 
  456  fl_state = (cty.POINTER(FL_State)).in_dll(load_so_libforms(), 'fl_state') 
  457  fl_ul_magic_char = (STRING).in_dll(load_so_libforms(), 'fl_state') 
  458   
  459   
  460  ######################################## 
  461  # forms.h (Basic.h) 
  462  #  Basic definitions and limits. 
  463  #  Window system independent prototypes 
  464  #  Modify with care 
  465  ######################################## 
  466   
  467   
  468 -def FL_IS_UPBOX(t): 
  469      if (t == FL_UP_BOX) or \ 
  470          (t == FL_OVAL3D_UPBOX) or \ 
  471          (t == FL_ROUNDED3D_UPBOX): 
  472          return True 
  473      else: 
  474          return False 
  475   
  476   
  477 -def FL_IS_DOWNBOX(t): 
  478      if (t == FL_DOWN_BOX) or \ 
  479          (t == FL_OVAL3D_DOWNBOX) or \ 
  480          (t == FL_ROUNDED3D_DOWNBOX): 
  481          return True 
  482      else: 
  483          return False 
  484   
  485   
  486 -def FL_TO_DOWNBOX(t): 
  487      if t == FL_UP_BOX: 
  488          t1 = FL_DOWN_BOX 
  489      elif t == FL_ROUNDED3D_UPBOX: 
  490          t1 = FL_ROUNDED3D_DOWNBOX 
  491      elif t == FL_OVAL3D_UPBOX: 
  492          t1 = FL_OVAL3D_DOWNBOX 
  493      else: 
  494          t1 = t 
  495      return t1 
  496   
  497   
  498 -def special_style(a): 
  499      if (a >= FL_SHADOW_STYLE) and \ 
  500       (a <= (FL_EMBOSSED_STYLE + FL_MAXFONTS)): 
  501          return True 
  502      else: 
  503          return False 
  504   
  505   
  506   
  507   
  508  # Macro for getting at the object handlers return value 
  509   
  510 -def fl_object_returned(pObject): 
  511      return pObject.contents.returned 
  512   
  513   
  514  # IO other than XEvent Q 
  515   
  516  FL_IO_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  517   
  518 -def fl_add_io_callback(fd, mask, py_IoCallback, data): 
  519      """ 
  520          fl_add_io_callback(fd, mask, py_IoCallback, data) 
  521   
  522          Registers an input callback function when input is available from fd. 
  523   
  524          @param fd : a valid file descriptor in a *nix system 
  525          @param mask : under what circumstance the input callback should be 
  526             invoked (i.e. FL_READ, FL_WRITE or FL_EXCEPT) 
  527          @param py_IoCallback : python function to be invoked under mask 
  528             condition, fn(num, ptr_void) 
  529          @param data : argument to be passed to function 
  530      """ 
  531   
  532      _fl_add_io_callback = cfuncproto( 
  533              load_so_libforms(), "fl_add_io_callback", \ 
  534              None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK, cty.c_void_p], \ 
  535              """void fl_add_io_callback(int fd, unsigned int mask, 
  536                 FL_IO_CALLBACK callback, void * data) 
  537              """) 
  538      ifd = convert_to_int(fd) 
  539      uimask = convert_to_uint(mask) 
  540      c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 
  541      pdata = cty.cast(data, cty.c_void_p) 
  542      keep_cfunc_refs(c_IoCallback, py_IoCallback) 
  543      keep_elem_refs(fd, ifd, mask, uimask, data, pdata) 
  544      _fl_add_io_callback(ifd, uimask, c_IoCallback, pdata) 
  545   
  546   
  547 -def fl_remove_io_callback(fd, mask, py_IoCallback): 
  548      """ 
  549          fl_remove_io_callback(fd, mask, py_IoCallback) 
  550   
  551          Removes the registered callback function when input is available 
  552          from fd. 
  553   
  554          @param fd : a valid file descriptor in a unix system 
  555          @param mask : under what circumstance the input callback should be 
  556             removed (i.e. xfc.FL_READ, xfc.FL_WRITE, xfc.FL_EXCEPT) 
  557          @param py_IoCallback : python function to be removed under mask 
  558             condition, fn(num, ptr_void) 
  559      """ 
  560   
  561      _fl_remove_io_callback = cfuncproto( 
  562              load_so_libforms(), "fl_remove_io_callback", \ 
  563              None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK], \ 
  564              """void fl_remove_io_callback(int fd, unsigned int mask, 
  565                 FL_IO_CALLBACK cb) 
  566              """) 
  567      check_admitted_listvalues(mask, ASYNCIO_list) 
  568      ifd = convert_to_int(fd) 
  569      uimask = convert_to_uint(mask) 
  570      c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 
  571      keep_cfunc_refs(c_IoCallback, py_IoCallback) 
  572      keep_elem_refs(fd, ifd, mask, uimask) 
  573      _fl_remove_io_callback(ifd, uimask, c_IoCallback) 
  574   
  575   
  576  # signals 
  577   
  578  FL_SIGNAL_HANDLER = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  579   
  580 -def fl_add_signal_callback(sglnum, py_SignalHandler, data): 
  581      """ 
  582          fl_add_signal_callback(sglnum, py_SignalHandler, data) 
  583   
  584          Handles the receipt of a signal by registering a callback function 
  585          that gets called when a signal is caught (only 1 function per signal) 
  586   
  587          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  588          @param py_SignalHandler : python function to be invoked after 
  589             catching the signal, fn(num, ptr_void) 
  590          @param data : argument to be passed to function 
  591      """ 
  592   
  593      _fl_add_signal_callback = cfuncproto( 
  594              load_so_libforms(), "fl_add_signal_callback", \ 
  595              None, [cty.c_int, FL_SIGNAL_HANDLER, cty.c_void_p], \ 
  596              """void fl_add_signal_callback(int s, FL_SIGNAL_HANDLER cb, 
  597                 void * data) 
  598              """) 
  599      isglnum = convert_to_int(sglnum) 
  600      c_SignalHandler = FL_SIGNAL_HANDLER(py_SignalHandler) 
  601      pdata = cty.cast(data, cty.c_void_p) 
  602      keep_cfunc_refs(c_SignalHandler, py_SignalHandler) 
  603      keep_elem_refs(sglnum, isglnum, data, pdata) 
  604      _fl_add_signal_callback(isglnum, c_SignalHandler, pdata) 
  605   
  606   
  607 -def fl_remove_signal_callback(sglnum): 
  608      """ 
  609          fl_remove_signal_callback(sglnum) 
  610   
  611          Removes a previously registered callback function related to a signal. 
  612   
  613          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  614      """ 
  615   
  616      _fl_remove_signal_callback = cfuncproto( 
  617              load_so_libforms(), "fl_remove_signal_callback", \ 
  618              None, [cty.c_int], \ 
  619              """void fl_remove_signal_callback(int s) 
  620              """) 
  621      isglnum = convert_to_int(sglnum) 
  622      keep_elem_refs(sglnum, isglnum) 
  623      _fl_remove_signal_callback(isglnum) 
  624   
  625   
  626 -def fl_signal_caught(sglnum): 
  627      """ 
  628          fl_signal_caught(sglnum) 
  629   
  630          Informs the main loop of the delivery of the signal signum, the signal 
  631          is received by the application program 
  632   
  633          @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 
  634      """ 
  635   
  636      _fl_signal_caught = cfuncproto( 
  637              load_so_libforms(), "fl_signal_caught", \ 
  638              None, [cty.c_int], \ 
  639              """void fl_signal_caught(int s) 
  640              """) 
  641      isglnum = convert_to_int(sglnum) 
  642      keep_elem_refs(sglnum, isglnum) 
  643      _fl_signal_caught(isglnum) 
  644   
  645   
  646 -def fl_app_signal_direct(flag): 
  647      """ 
  648          fl_app_signal_direct(flag) 
  649   
  650          Changes the default behavior of the built-in signal facilities (to 
  651          be called with a true value for flag prior to any use of 
  652          fl_add_signal_callback 
  653   
  654          @param flag : flag (0|1) 
  655      """ 
  656   
  657      _fl_app_signal_direct = cfuncproto( 
  658              load_so_libforms(), "fl_app_signal_direct", \ 
  659              None, [cty.c_int], \ 
  660              """void fl_app_signal_direct(int y) 
  661              """) 
  662      iflag = convert_to_int(flag) 
  663      keep_elem_refs(flag, iflag) 
  664      _fl_app_signal_direct(iflag) 
  665   
  666   
  667  # timeouts 
  668   
  669  FL_TIMEOUT_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
  670   
  671 -def fl_add_timeout(msec, py_TimeoutCallback, data): 
  672      """ 
  673          fl_add_timeout(msec, py_TimeoutCallback, data) -> timer ID 
  674   
  675          Adds a timeout callback after a specified elapsed time. 
  676   
  677          @param msec : time elapsed in milliseconds 
  678          @param py_TimeoutCallback : python function to be invoked after time, 
  679             fn(num, ptr_void) 
  680          @param data : argument to be passed to function 
  681      """ 
  682   
  683      _fl_add_timeout = cfuncproto( 
  684              load_so_libforms(), "fl_add_timeout", \ 
  685              cty.c_int, [cty.c_long, FL_TIMEOUT_CALLBACK, cty.c_void_p], \ 
  686              """int fl_add_timeout(long int msec, 
  687                 FL_TIMEOUT_CALLBACK callback, void * data) 
  688              """) 
  689      lmsec = convert_to_long(msec) 
  690      pdata = cty.cast(data, cty.c_void_p) 
  691      c_TimeoutCallback = FL_TIMEOUT_CALLBACK(py_TimeoutCallback) 
  692      keep_cfunc_refs(c_TimeoutCallback, py_TimeoutCallback) 
  693      keep_elem_refs(msec, lmsec, data, pdata) 
  694      retval = _fl_add_timeout(lmsec, c_TimeoutCallback, pdata) 
  695      return retval 
  696   
  697   
  698 -def fl_remove_timeout(idnum): 
  699      """ 
  700          fl_remove_timeout(idnum) 
  701   
  702          Removes a timeout callback function (created with fl_add_timeout). 
  703   
  704          @param idnum : ID timeout number 
  705      """ 
  706   
  707      _fl_remove_timeout = cfuncproto( 
  708              load_so_libforms(), "fl_remove_timeout", \ 
  709              None, [cty.c_int], \ 
  710              """void fl_remove_timeout(int id) 
  711              """) 
  712      iidnum = convert_to_int(idnum) 
  713      keep_elem_refs(idnum, iidnum) 
  714      _fl_remove_timeout(iidnum) 
  715   
  716   
  717  # Basic public routine prototypes 
  718   
  719  #def fl_library_version(ver, rev)       *API change* 
  720 -def fl_library_version(): 
  721      """ 
  722          fl_library_version() -> version_rev ID, ver, rev 
  723   
  724          Returns consolidated version informations. 
  725   
  726          Returns: 
  727          <version_rev> : computed as 1000 * version + revision 
  728          <ver> : version (e.g. 1 in 1.x.yy) 
  729          <rev> : revision (e.g. 0 in x.0.yy) 
  730      """ 
  731   
  732      _fl_library_version = cfuncproto( 
  733              load_so_libforms(), "fl_library_version", \ 
  734              cty.c_int, [cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], \ 
  735              """int fl_library_version(int * ver, int * rev) 
  736              """) 
  737      ver, pver = make_int_and_pointer() 
  738      rev, prev = make_int_and_pointer() 
  739      keep_elem_refs(ver, rev, pver, prev) 
  740      retval = _fl_library_version(pver, prev) 
  741      return retval, ver, rev 
  742   
  743   
  744  # Generic routines that deal with FORMS 
  745   
  746 -def fl_bgn_form(formtype, w, h): 
  747      """ 
  748          fl_bgn_form(formtype, w, h) -> pForm 
  749   
  750          Starts the definition of a form call. 
  751   
  752          @param formtype : type of box that is used as a background 
  753             (e.g. FL_DOWN_BOX, FL_BORDER_BOX, FL_SHADOW_BOX, etc.) 
  754          @param w : width of the new form 
  755          @param h : height of the new form 
  756      """ 
  757   
  758      _fl_bgn_form = cfuncproto( 
  759              load_so_libforms(), "fl_bgn_form", \ 
  760              cty.POINTER(FL_FORM), [cty.c_int, FL_Coord, FL_Coord], \ 
  761              """FL_FORM * fl_bgn_form(int type, FL_Coord w, FL_Coord h) 
  762              """) 
  763      check_admitted_listvalues(formtype, BOXTYPE_list) 
  764      iformtype = convert_to_int(formtype) 
  765      iw = convert_to_FL_Coord(w) 
  766      ih = convert_to_FL_Coord(h) 
  767      keep_elem_refs(formtype, iformtype, w, iw, h, ih) 
  768      retval = _fl_bgn_form(iformtype, iw, ih) 
  769      return retval 
  770   
  771   
  772 -def fl_end_form(): 
  773      """ 
  774          fl_end_form() 
  775   
  776          Ends the definition for a form call, after all required objects 
  777          have been added to a form call. 
  778      """ 
  779   
  780      _fl_end_form = cfuncproto( 
  781              load_so_libforms(), "fl_end_form", \ 
  782              None, [], \ 
  783              """void fl_end_form() 
  784              """) 
  785      _fl_end_form() 
  786   
  787   
  788 -def fl_do_forms(): 
  789      """ 
  790          fl_do_forms() -> pObject 
  791   
  792          Starts the main loop of the program and returns only when the state 
  793          of an object changes that has no callback bound to it. 
  794      """ 
  795   
  796      _fl_do_forms = cfuncproto( 
  797              load_so_libforms(), "fl_do_forms", \ 
  798              cty.POINTER(FL_OBJECT), [], \ 
  799              """FL_OBJECT * fl_do_forms() 
  800              """) 
  801      retval = _fl_do_forms() 
  802      return retval 
  803   
  804   
  805 -def fl_check_forms(): 
  806      """ 
  807          fl_check_forms() -> pObject 
  808   
  809          Returns None immediately unless the state of one of the object 
  810          (without a callback bound to it) changed. 
  811      """ 
  812   
  813      _fl_check_forms = cfuncproto( 
  814              load_so_libforms(), "fl_check_forms", \ 
  815              cty.POINTER(FL_OBJECT), [], \ 
  816              """FL_OBJECT * fl_check_forms() 
  817              """) 
  818      retval = _fl_check_forms() 
  819      return retval 
  820   
  821   
  822 -def fl_do_only_forms(): 
  823      """ 
  824          fl_do_only_forms() -> pObject 
  825   
  826          Starts the main loop of the program and returns only when the state of 
  827          an object changes that has no callback bound to it. It does not 
  828          handle user events generated by application windows opened via 
  829          fl_winopen() or similar routines. 
  830      """ 
  831   
  832      _fl_do_only_forms = cfuncproto( 
  833              load_so_libforms(), "fl_do_only_forms", \ 
  834              cty.POINTER(FL_OBJECT), [], \ 
  835              """FL_OBJECT * fl_do_only_forms() 
  836              """) 
  837      retval = _fl_do_only_forms() 
  838      return retval 
  839   
  840   
  841 -def fl_check_only_forms(): 
  842      """ 
  843          fl_check_only_forms() -> pObject 
  844   
  845          Returns None immediately unless the state of one of the object 
  846          (without a callback bound to it) changed. It does not handle user 
  847          events generated by application windows opened via fl_winopen() or 
  848          similar routines. 
  849      """ 
  850   
  851      _fl_check_only_forms = cfuncproto( 
  852              load_so_libforms(), "fl_check_only_forms", \ 
  853              cty.POINTER(FL_OBJECT), [], \ 
  854              """FL_OBJECT * fl_check_only_forms() 
  855              """) 
  856      retval = _fl_check_only_forms() 
  857      return retval 
  858   
  859   
  860 -def fl_freeze_form(pForm): 
  861      """ 
  862          fl_freeze_form(pForm) 
  863   
  864          It does not temporarily redraw a form while changes are being made, so 
  865          all changes made are instead buffered internally. 
  866   
  867          @param pForm : pointer to form not to be re-drawn temporarly 
  868      """ 
  869   
  870      _fl_freeze_form = cfuncproto( 
  871              load_so_libforms(), "fl_freeze_form", \ 
  872              None, [cty.POINTER(FL_FORM)], \ 
  873              """void fl_freeze_form(FL_FORM * form) 
  874              """) 
  875      keep_elem_refs(pForm) 
  876      _fl_freeze_form(pForm) 
  877   
  878   
  879 -def fl_set_focus_object(pForm, pObject): 
  880      """ 
  881          fl_set_focus_object(pForm, pObject) 
  882   
  883          Sets the input focus in form to object pObject. 
  884   
  885          @param pForm : pointer to form whose object has to be focused 
  886          @param pObject : pointer to object to be focused 
  887      """ 
  888   
  889      _fl_set_focus_object = cfuncproto( 
  890              load_so_libforms(), "fl_set_focus_object", \ 
  891              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 
  892              """void fl_set_focus_object(FL_FORM * form, FL_OBJECT * obj) 
  893              """) 
  894      keep_elem_refs(pForm, pObject) 
  895      _fl_set_focus_object(pForm, pObject) 
  896   
  897   
  898  fl_set_object_focus = fl_set_focus_object 
  899   
  900   
  901 -def fl_get_focus_object(pForm): 
  902      """ 
  903          fl_get_focus_object(pForm) -> pObject 
  904   
  905          Obtains the object that has the focus on a form. 
  906   
  907          @param pForm : pointer to form that has a focused object 
  908      """ 
  909   
  910      _fl_get_focus_object = cfuncproto( 
  911              load_so_libforms(), "fl_get_focus_object", \ 
  912              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_FORM)], \ 
  913              """FL_OBJECT * fl_get_focus_object(FL_FORM * form) 
  914              """) 
  915      keep_elem_refs(pForm) 
  916      retval = _fl_get_focus_object(pForm) 
  917      return retval 
  918   
  919   
  920 -def fl_reset_focus_object(pObject): 
  921      """ 
  922          fl_reset_focus_object(pObject) 
  923   
  924          Override the FL_UNFOCUS event. 
  925   
  926          @param pObject : pointer to object towards applying event 
  927      """ 
  928   
  929      _fl_reset_focus_object = cfuncproto( 
  930              load_so_libforms(), "fl_reset_focus_object", \ 
  931              None, [cty.POINTER(FL_OBJECT)], \ 
  932              """void fl_reset_focus_object(FL_OBJECT * ob) 
  933              """) 
  934      keep_elem_refs(pObject) 
  935      _fl_reset_focus_object(pObject) 
  936   
  937   
  938  #already defined in xfdata 
  939  #FL_FORM_ATCLOSE = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 
  940   
  941 -def fl_set_form_atclose(pForm, py_FormAtclose, data): 
  942      """ 
  943          fl_set_form_atclose(pForm, py_FormAtclose, data) -> FormAtclose func. 
  944   
  945          Calls a callback function before closing the form. 
  946   
  947          @param pForm : pointer to form that receives the message 
  948          @param py_FormAtclose : python callback function to be called, 
  949             fn(pForm, ptr_void) -> num 
  950          @param data : argument to be passed to function 
  951      """ 
  952   
  953      _fl_set_form_atclose = cfuncproto( 
  954              load_so_libforms(), "fl_set_form_atclose", \ 
  955              FL_FORM_ATCLOSE, [cty.POINTER(FL_FORM), FL_FORM_ATCLOSE, 
  956              cty.c_void_p], \ 
  957              """FL_FORM_ATCLOSE fl_set_form_atclose(FL_FORM * form, 
  958                 FL_FORM_ATCLOSE fmclose, void * data) 
  959              """) 
  960      c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 
  961      pdata = cty.cast(data, cty.c_void_p) 
  962      keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 
  963      keep_elem_refs(pForm, data, pdata) 
  964      retval = _fl_set_form_atclose(pForm, c_FormAtclose, pdata) 
  965      return retval 
  966   
  967   
  968 -def fl_set_atclose(py_FormAtclose, data): 
  969      """ 
  970          fl_set_atclose(py_FormAtclose, data) -> FormAtclose func. 
  971   
  972          Calls a callback function before terminating the application. 
  973   
  974          @param py_FormAtclose : callback function to be called, fn(pForm, 
  975             ptr_void) -> num 
  976          @param data : argument to be passed to function 
  977      """ 
  978   
  979      _fl_set_atclose = cfuncproto( 
  980              load_so_libforms(), "fl_set_atclose", \ 
  981              FL_FORM_ATCLOSE, [FL_FORM_ATCLOSE, cty.c_void_p], \ 
  982              """FL_FORM_ATCLOSE fl_set_atclose(FL_FORM_ATCLOSE fmclose, 
  983                 void * data) 
  984              """) 
  985      c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 
  986      pdata = cty.cast(data, cty.c_void_p) 
  987      keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 
  988      keep_elem_refs(data, pdata) 
  989      retval = _fl_set_atclose(c_FormAtclose, pdata) 
  990      return retval 
  991   
  992   
  993  #already defined in xfdata 
  994  #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 
  995   
  996 -def fl_set_form_atactivate(pForm, py_FormAtactivate, data): 
  997      """ 
  998          fl_set_form_atactivate(pForm, py_FormAtactivate, data) -> FormAtactivate func. 
  999   
 1000          Register a callback that is called when activation status of a forms 
 1001          is enabled, 
 1002   
 1003          @param pForm : activated form 
 1004          @param py_FormAtactivate : python callback function called, fn(pForm, 
 1005             ptr_void) 
 1006          @param data : argument to be passed to function 
 1007      """ 
 1008   
 1009      _fl_set_form_atactivate = cfuncproto( 
 1010              load_so_libforms(), "fl_set_form_atactivate", \ 
 1011              FL_FORM_ATACTIVATE, [cty.POINTER(FL_FORM), FL_FORM_ATACTIVATE, 
 1012              cty.c_void_p], \ 
 1013              """FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form, 
 1014                 FL_FORM_ATACTIVATE cb, void * data) 
 1015              """) 
 1016      c_FormAtactivate = FL_FORM_ATACTIVATE(py_FormAtactivate) 
 1017      pdata = cty.cast(data, cty.c_void_p) 
 1018      keep_cfunc_refs(c_FormAtactivate, py_FormAtactivate) 
 1019      keep_elem_refs(pForm, data, pdata) 
 1020      retval = _fl_set_form_atactivate(pForm, c_FormAtactivate, pdata) 
 1021      return retval 
 1022   
 1023   
 1024  #already defined in xfdata 
 1025  #FL_FORM_ATDEACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 
 1026   
 1027 -def fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data): 
 1028      """ 
 1029          fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data) -> FormAtdeactivate func. 
 1030   
 1031          Register a callback that is called when activation status of a forms 
 1032          is disabled. 
 1033   
 1034          @param pForm : pointer to de-activated form 
 1035          @param py_FormAtdeactivate : python callback function called, 
 1036             fn(pForm, ptr_void) 
 1037          @param data : argument to be passed to function 
 1038      """ 
 1039   
 1040      _fl_set_form_atdeactivate = cfuncproto( 
 1041              load_so_libforms(), "fl_set_form_atdeactivate", \ 
 1042              FL_FORM_ATDEACTIVATE, [cty.POINTER(FL_FORM), 
 1043              FL_FORM_ATDEACTIVATE, cty.c_void_p], \ 
 1044              """FL_FORM_ATDEACTIVATE fl_set_form_atdeactivate(FL_FORM * form, 
 1045                 FL_FORM_ATDEACTIVATE cb, void * data) 
 1046              """) 
 1047      c_FormAtdeactivate = FL_FORM_ATDEACTIVATE(py_FormAtdeactivate) 
 1048      pdata = cty.cast(data, cty.c_void_p) 
 1049      keep_cfunc_refs(c_FormAtdeactivate, py_FormAtdeactivate) 
 1050      keep_elem_refs(pForm, data, pdata) 
 1051      retval = _fl_set_form_atdeactivate(pForm, c_FormAtdeactivate, pdata) 
 1052      return retval 
 1053   
 1054   
 1055 -def fl_unfreeze_form(pForm): 
 1056      """ 
 1057          fl_unfreeze_form(pForm) 
 1058   
 1059          All changes made in the meantime in a form are drawn at once, 
 1060          reverting previous freeze. 
 1061   
 1062          @param pForm : pointer to form to be re-drawn after freezing 
 1063      """ 
 1064   
 1065      _fl_unfreeze_form = cfuncproto( 
 1066              load_so_libforms(), "fl_unfreeze_form", \ 
 1067              None, [cty.POINTER(FL_FORM)], \ 
 1068              """void fl_unfreeze_form(FL_FORM * form) 
 1069              """) 
 1070      keep_elem_refs(pForm) 
 1071      _fl_unfreeze_form(pForm) 
 1072   
 1073   
 1074 -def fl_deactivate_form(pForm): 
 1075      """ 
 1076          fl_deactivate_form(pForm) 
 1077   
 1078          Deactivates form temporarily, without hiding it, but not allowing the 
 1079          user to interact with elements contained in form (buttons, etc.). 
 1080   
 1081          @param pForm : pointer to form to be de-activated 
 1082      """ 
 1083   
 1084      _fl_deactivate_form = cfuncproto( 
 1085              load_so_libforms(), "fl_deactivate_form", \ 
 1086              None, [cty.POINTER(FL_FORM)], \ 
 1087              """void fl_deactivate_form(FL_FORM * form) 
 1088              """) 
 1089      keep_elem_refs(pForm) 
 1090      _fl_deactivate_form(pForm) 
 1091   
 1092   
 1093 -def fl_activate_form(pForm): 
 1094      """ 
 1095          fl_activate_form(pForm) 
 1096   
 1097          (Re)activates form, allowing the user to interact again with elements 
 1098          contained in form (buttons, etc.). 
 1099   
 1100          @param pForm : pointer to form to be re-activated 
 1101      """ 
 1102   
 1103      _fl_activate_form = cfuncproto( 
 1104              load_so_libforms(), "fl_activate_form", \ 
 1105              None, [cty.POINTER(FL_FORM)], \ 
 1106              """void fl_activate_form(FL_FORM * form) 
 1107              """) 
 1108      keep_elem_refs(pForm) 
 1109      _fl_activate_form(pForm) 
 1110   
 1111   
 1112 -def fl_deactivate_all_forms(): 
 1113      """ 
 1114          fl_deactivate_all_forms() 
 1115   
 1116          De-activates all current forms, forbidding any user interactions. 
 1117      """ 
 1118   
 1119      _fl_deactivate_all_forms = cfuncproto( 
 1120              load_so_libforms(), "fl_deactivate_all_forms", \ 
 1121              None, [], \ 
 1122              """void fl_deactivate_all_forms() 
 1123              """) 
 1124      _fl_deactivate_all_forms() 
 1125   
 1126   
 1127 -def fl_activate_all_forms(): 
 1128      """ 
 1129          fl_activate_all_forms() 
 1130   
 1131          (Re)activates all current forms, allowing user interaction. 
 1132      """ 
 1133   
 1134      _fl_activate_all_forms = cfuncproto( 
 1135              load_so_libforms(), "fl_activate_all_forms", \ 
 1136              None, [], \ 
 1137              """void fl_activate_all_forms() 
 1138              """) 
 1139      _fl_activate_all_forms() 
 1140   
 1141   
 1142 -def fl_freeze_all_forms(): 
 1143      """ 
 1144          fl_freeze_all_forms() 
 1145   
 1146          It does not temporarily redraw all current forms while changes are 
 1147          being made, so all changes made are instead buffered internally. 
 1148      """ 
 1149   
 1150      _fl_freeze_all_forms = cfuncproto( 
 1151              load_so_libforms(), "fl_freeze_all_forms", \ 
 1152              None, [], \ 
 1153              """void fl_freeze_all_forms() 
 1154              """) 
 1155      _fl_freeze_all_forms() 
 1156   
 1157   
 1158 -def fl_unfreeze_all_forms(): 
 1159      """ 
 1160          fl_unfreeze_all_forms() 
 1161   
 1162          All changes made in the meantime in all current forms are drawn at 
 1163          once, reverting previous freeze. 
 1164      """ 
 1165   
 1166      _fl_unfreeze_all_forms = cfuncproto( 
 1167              load_so_libforms(), "fl_unfreeze_all_forms", \ 
 1168              None, [], \ 
 1169              """void fl_unfreeze_all_forms() 
 1170              """) 
 1171      _fl_unfreeze_all_forms() 
 1172   
 1173   
 1174 -def fl_scale_form(pForm, xsc, ysc): 
 1175      """ 
 1176          fl_scale_form(pForm, xsc, ysc) 
 1177   
 1178          Scales a form and the objects on it in size and position, indicating 
 1179          a scaling factor in x- and y-direction with respect to the current 
 1180          size, and reshapes the window. 
 1181   
 1182          @param pForm : pointer to form to be scaled 
 1183          @param xsc : scaling factor in horizontal direction 
 1184          @param ysc : scaling factor in vertical direction 
 1185      """ 
 1186   
 1187      _fl_scale_form = cfuncproto( 
 1188              load_so_libforms(), "fl_scale_form", \ 
 1189              None, [cty.POINTER(FL_FORM), cty.c_double, cty.c_double], \ 
 1190              """void fl_scale_form(FL_FORM * form, double xsc, double ysc) 
 1191              """) 
 1192      fxsc = convert_to_double(xsc) 
 1193      fysc = convert_to_double(ysc) 
 1194      keep_elem_refs(pForm, xsc, fxsc, ysc, fysc) 
 1195      _fl_scale_form(pForm, fxsc, fysc) 
 1196   
 1197   
 1198 -def fl_set_form_position(pForm, x, y): 
 1199      """ 
 1200          fl_set_form_position(pForm, x, y) 
 1201   
 1202          Sets position of form, when placing a form on the screen with 
 1203          FL_PLACE_GEOMETRY as place argument. 
 1204   
 1205          @param pForm : pointer to form whose position is to be set 
 1206          @param x : horizontal position 
 1207          @param y : vertical position 
 1208      """ 
 1209   
 1210      _fl_set_form_position = cfuncproto( 
 1211              load_so_libforms(), "fl_set_form_position", \ 
 1212              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1213              """void fl_set_form_position(FL_FORM * form, FL_Coord x, 
 1214                 FL_Coord y) 
 1215              """) 
 1216      ix = convert_to_FL_Coord(x) 
 1217      iy = convert_to_FL_Coord(y) 
 1218      keep_elem_refs(pForm, x, ix, y, iy) 
 1219      _fl_set_form_position(pForm, ix, iy) 
 1220   
 1221   
 1222 -def fl_set_form_title(pForm, name): 
 1223      """ 
 1224          fl_set_form_title(pForm, name) 
 1225   
 1226          Changes the form title (and the icon name) after it is shown. 
 1227   
 1228          @param pForm : pointer to form whose title has to be changed 
 1229          @param name : new name for the form 
 1230      """ 
 1231   
 1232      _fl_set_form_title = cfuncproto( 
 1233              load_so_libforms(), "fl_set_form_title", \ 
 1234              None, [cty.POINTER(FL_FORM), STRING], \ 
 1235              """void fl_set_form_title(FL_FORM * form, const char * name) 
 1236              """) 
 1237      sname = convert_to_string(name) 
 1238      keep_elem_refs(pForm, name, sname) 
 1239      _fl_set_form_title(pForm, sname) 
 1240   
 1241   
 1242 -def fl_set_app_mainform(pForm): 
 1243      """ fl_set_app_mainform(pForm) 
 1244      """ 
 1245   
 1246      _fl_set_app_mainform = cfuncproto( 
 1247              load_so_libforms(), "fl_set_app_mainform", 
 1248              None, [cty.POINTER(FL_FORM)], \ 
 1249              """void fl_set_app_mainform(FL_FORM * form) 
 1250              """) 
 1251      keep_elem_refs(pForm) 
 1252      _fl_set_app_mainform(pForm) 
 1253   
 1254   
 1255 -def fl_get_app_mainform(): 
 1256      """ fl_get_app_mainform() -> pForm 
 1257      """ 
 1258   
 1259      _fl_get_app_mainform = cfuncproto( 
 1260              load_so_libforms(), "fl_get_app_mainform", 
 1261              cty.POINTER(FL_FORM), [], \ 
 1262              """FL_FORM * fl_get_app_mainform() 
 1263              """) 
 1264      retval = _fl_get_app_mainform() 
 1265      return retval 
 1266   
 1267   
 1268 -def fl_set_app_nomainform(flag): 
 1269      """ fl_set_app_nomainform(flag) 
 1270      """ 
 1271   
 1272      _fl_set_app_nomainform = cfuncproto( 
 1273              load_so_libforms(), "fl_set_app_nomainform", 
 1274              None, [cty.c_int], \ 
 1275              """void fl_set_app_nomainform(int flag) 
 1276              """) 
 1277      iflag = convert_to_int(flag) 
 1278      keep_elem_refs(flag, iflag) 
 1279      _fl_set_app_nomainform(iflag) 
 1280   
 1281   
 1282  #already defined in xfdata 
 1283  #FL_FORMCALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_void_p) 
 1284   
 1285 -def fl_set_form_callback(pForm, py_FormCallbackPtr, data): 
 1286      """ fl_set_form_callback(pForm, py_FormCallbackPtr, data) 
 1287   
 1288          Sets the callback routine for the form. 
 1289   
 1290          @param pForm : pointer to form 
 1291          @param py_FormCallbackPtr : python callback to be set, 
 1292             fn(pObject, ptr_void) 
 1293          @param data : argument to be passed to function 
 1294      """ 
 1295   
 1296      _fl_set_form_callback = cfuncproto( 
 1297              load_so_libforms(), "fl_set_form_callback", \ 
 1298              None, [cty.POINTER(FL_FORM), FL_FORMCALLBACKPTR, cty.c_void_p], \ 
 1299              """void fl_set_form_callback(FL_FORM * form, 
 1300                 FL_FORMCALLBACKPTR callback, void * d) 
 1301              """) 
 1302      c_FormCallbackPtr = FL_FORMCALLBACKPTR(py_FormCallbackPtr) 
 1303      pdata = cty.cast(data, cty.c_void_p) 
 1304      keep_cfunc_refs(c_FormCallbackPtr, py_FormCallbackPtr) 
 1305      keep_elem_refs(pForm, data, pdata) 
 1306      _fl_set_form_callback(pForm, c_FormCallbackPtr, pdata) 
 1307   
 1308   
 1309  fl_set_form_call_back = fl_set_form_callback 
 1310   
 1311   
 1312 -def fl_set_form_size(pForm, w, h): 
 1313      """ 
 1314          fl_set_form_size(pForm, w, h) 
 1315   
 1316          Sets the size of form. 
 1317   
 1318          @param pForm : pointer to form 
 1319          @param w : width of form 
 1320          @param h : height of form 
 1321      """ 
 1322   
 1323      _fl_set_form_size = cfuncproto( 
 1324              load_so_libforms(), "fl_set_form_size", \ 
 1325              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1326              """void fl_set_form_size(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1327              """) 
 1328      iw = convert_to_FL_Coord(w) 
 1329      ih = convert_to_FL_Coord(h) 
 1330      keep_elem_refs(pForm, w, iw, h, ih) 
 1331      _fl_set_form_size(pForm, iw, ih) 
 1332   
 1333   
 1334 -def fl_set_form_hotspot(pForm, x, y): 
 1335      """ 
 1336          fl_set_form_hotspot(pForm, x, y) 
 1337   
 1338          Sets the position of the hotspot of a form. 
 1339   
 1340          @param pForm : pointer to form 
 1341          @param x : horizontal position 
 1342          @param y : vertical position 
 1343      """ 
 1344   
 1345      _fl_set_form_hotspot = cfuncproto( 
 1346              load_so_libforms(), "fl_set_form_hotspot", \ 
 1347              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1348              """void fl_set_form_hotspot(FL_FORM * form, FL_Coord x, 
 1349                 FL_Coord y) 
 1350              """) 
 1351      ix = convert_to_FL_Coord(x) 
 1352      iy = convert_to_FL_Coord(y) 
 1353      keep_elem_refs(pForm, x, ix, y, iy) 
 1354      _fl_set_form_hotspot(pForm, ix, iy) 
 1355   
 1356   
 1357 -def fl_set_form_hotobject(pForm, pObject): 
 1358      """ 
 1359          fl_set_form_hotobject(pForm, pObject) 
 1360   
 1361          @param pForm : pointer to form 
 1362          @param pObject : pointer to object 
 1363      """ 
 1364   
 1365      _fl_set_form_hotobject = cfuncproto( 
 1366              load_so_libforms(), "fl_set_form_hotobject", \ 
 1367              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 
 1368              """void fl_set_form_hotobject(FL_FORM * form, FL_OBJECT * ob) 
 1369              """) 
 1370      keep_elem_refs(pForm, pObject) 
 1371      _fl_set_form_hotobject(pForm, pObject) 
 1372   
 1373   
 1374 -def fl_set_form_minsize(pForm, w, h): 
 1375      """ 
 1376          fl_set_form_minsize(pForm, w, h) 
 1377   
 1378          @param pForm : pointer to form 
 1379          @param w : width of form 
 1380          @param h : height of form 
 1381      """ 
 1382   
 1383      _fl_set_form_minsize = cfuncproto( 
 1384              load_so_libforms(), "fl_set_form_minsize", \ 
 1385              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1386              """void fl_set_form_minsize(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1387              """) 
 1388      iw = convert_to_FL_Coord(w) 
 1389      ih = convert_to_FL_Coord(h) 
 1390      keep_elem_refs(pForm, w, iw, h, ih) 
 1391      _fl_set_form_minsize(pForm, iw, ih) 
 1392   
 1393   
 1394 -def fl_set_form_maxsize(pForm, w, h): 
 1395      """ 
 1396          fl_set_form_maxsize(pForm, w, h) 
 1397   
 1398          @param pForm : pointer to form 
 1399          @param w : width of form 
 1400          @param h : height of form 
 1401      """ 
 1402   
 1403      _fl_set_form_maxsize = cfuncproto( 
 1404              load_so_libforms(), "fl_set_form_maxsize", \ 
 1405              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 
 1406              """void fl_set_form_maxsize(FL_FORM * form, FL_Coord w, FL_Coord h) 
 1407              """) 
 1408      iw = convert_to_FL_Coord(w) 
 1409      ih = convert_to_FL_Coord(h) 
 1410      keep_elem_refs(pForm, w, iw, h, ih) 
 1411      _fl_set_form_maxsize(pForm, iw, ih) 
 1412   
 1413   
 1414 -def fl_set_form_event_cmask(pForm, cmask): 
 1415      """ 
 1416          fl_set_form_event_cmask(pForm, cmask) 
 1417   
 1418          @param pForm : pointer to form 
 1419          @param cmask : compress mask for form 
 1420      """ 
 1421   
 1422      _fl_set_form_event_cmask = cfuncproto( 
 1423              load_so_libforms(), "fl_set_form_event_cmask", \ 
 1424              None, [cty.POINTER(FL_FORM), cty.c_ulong], \ 
 1425              """void fl_set_form_event_cmask(FL_FORM * form, 
 1426                 long unsigned int cmask) 
 1427              """) 
 1428      ulcmask = convert_to_ulong(cmask) 
 1429      keep_elem_refs(pForm, cmask, ulcmask) 
 1430      _fl_set_form_event_cmask(pForm, ulcmask) 
 1431   
 1432   
 1433 -def fl_get_form_event_cmask(pForm): 
 1434      """ 
 1435          fl_get_form_event_cmask(pForm) -> compress mask ID 
 1436   
 1437          Returns event compress mask for form. 
 1438   
 1439          @param pForm : pointer to form 
 1440      """ 
 1441   
 1442      _fl_get_form_event_cmask = cfuncproto( 
 1443              load_so_libforms(), "fl_get_form_event_cmask", \ 
 1444              cty.c_ulong, [cty.POINTER(FL_FORM)], \ 
 1445              """long unsigned int fl_get_form_event_cmask(FL_FORM * form) 
 1446              """) 
 1447      keep_elem_refs(pForm) 
 1448      retval = _fl_get_form_event_cmask(pForm) 
 1449      return retval 
 1450   
 1451   
 1452  # alert until upstream bugfix 
 1453 -def fl_set_form_geometry(pForm, x, y, w, h): 
 1454      """ 
 1455          fl_set_form_geometry(pForm, x, y, w, h) 
 1456   
 1457          @param pForm : pointer to form 
 1458          @param x : horizontal position 
 1459          @param y : vertical position 
 1460          @param w : width of form 
 1461          @param h : height of form 
 1462      """ 
 1463   
 1464      _fl_set_form_geometry = cfuncproto( 
 1465              load_so_libforms(), "fl_set_form_geometry", \ 
 1466              None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord, 
 1467              FL_Coord, FL_Coord], \ 
 1468              """void fl_set_form_geometry(FL_FORM * form, FL_Coord x, 
 1469                 FL_Coord y, FL_Coord w, FL_Coord h) 
 1470              """) 
 1471      ix = convert_to_FL_Coord(x) 
 1472      iy = convert_to_FL_Coord(y) 
 1473      iw = convert_to_FL_Coord(w) 
 1474      ih = convert_to_FL_Coord(h) 
 1475      keep_elem_refs(pForm, x, ix, y, iy, w, iw, h, ih) 
 1476      _fl_set_form_geometry(pForm, ix, iy, iw, ih) 
 1477   
 1478   
 1479  fl_set_initial_placement = fl_set_form_geometry 
 1480   
 1481   
 1482 -def fl_show_form(pForm, place, border, title): 
 1483      """ 
 1484          fl_show_form(pForm, place, border, title) -> window id 
 1485   
 1486          Shows the form. 
 1487   
 1488          @param pForm : pointer to form 
 1489          @param place : where form has to be placed 
 1490          @param border : type of window manager decoration 
 1491          @param title : title of form 
 1492      """ 
 1493   
 1494      _fl_show_form = cfuncproto( 
 1495              load_so_libforms(), "fl_show_form", 
 1496              Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 
 1497              """Window fl_show_form(FL_FORM * form, int place, int border, 
 1498                 const char * name) 
 1499              """) 
 1500      check_admitted_listvalues(place, PLACE_list) 
 1501      check_admitted_listvalues(border, DECORATION_list) 
 1502      iplace = convert_to_int(place) 
 1503      iborder = convert_to_int(border) 
 1504      stitle = convert_to_string(title) 
 1505      keep_elem_refs(pForm, place, iplace, border, iborder, title, stitle) 
 1506      retval = _fl_show_form(pForm, iplace, iborder, stitle) 
 1507      return retval 
 1508   
 1509   
 1510 -def fl_hide_form(pForm): 
 1511      """ 
 1512          fl_hide_form(pForm) 
 1513   
 1514          Hides the form. 
 1515   
 1516          @param pForm : pointer to form 
 1517      """ 
 1518   
 1519      _fl_hide_form = cfuncproto( 
 1520              load_so_libforms(), "fl_hide_form", 
 1521              None, [cty.POINTER(FL_FORM)], \ 
 1522              """void fl_hide_form(FL_FORM * form) 
 1523              """) 
 1524      keep_elem_refs(pForm) 
 1525      _fl_hide_form(pForm) 
 1526   
 1527   
 1528 -def fl_free_form(pForm): 
 1529      """ 
 1530          fl_free_form(pForm) 
 1531   
 1532          Frees the memory used by a form together with all its objects. 
 1533   
 1534          @param pForm : pointer to form to be freed 
 1535      """ 
 1536   
 1537      _fl_free_form = cfuncproto( 
 1538              load_so_libforms(), "fl_free_form", 
 1539              None, [cty.POINTER(FL_FORM)], \ 
 1540              """void fl_free_form(FL_FORM * form) 
 1541              """) 
 1542      keep_elem_refs(pForm) 
 1543      _fl_free_form(pForm) 
 1544   
 1545   
 1546 -def fl_redraw_form(pForm): 
 1547      """ 
 1548          fl_redraw_form(pForm) 
 1549   
 1550          Draws a form. 
 1551   
 1552          @param pForm : pointer to form 
 1553      """ 
 1554   
 1555      _fl_redraw_form = cfuncproto( 
 1556              load_so_libforms(), "fl_redraw_form", 
 1557              None, [cty.POINTER(FL_FORM)], \ 
 1558              """void fl_redraw_form(FL_FORM * form) 
 1559              """) 
 1560      keep_elem_refs(pForm) 
 1561      _fl_redraw_form(pForm) 
 1562   
 1563   
 1564 -def fl_set_form_dblbuffer(pForm, y): 
 1565      """ 
 1566          fl_set_form_dblbuffer(pForm, y) 
 1567   
 1568          @param pForm : pointer to form 
 1569          @param y : flag (0|1) for disabling/enabling doublebuffer 
 1570      """ 
 1571   
 1572      _fl_set_form_dblbuffer = cfuncproto( 
 1573              load_so_libforms(), "fl_set_form_dblbuffer", \ 
 1574              None, [cty.POINTER(FL_FORM), cty.c_int], \ 
 1575              """void fl_set_form_dblbuffer(FL_FORM * form, int y) 
 1576              """) 
 1577      iy = convert_to_int(y) 
 1578      keep_elem_refs(pForm, y, iy) 
 1579      _fl_set_form_dblbuffer(pForm, iy) 
 1580   
 1581   
 1582 -def fl_prepare_form_window(pForm, place, border, name): 
 1583      """ 
 1584          fl_prepare_form_window(pForm, place, border, name) -> window ID 
 1585   
 1586          Displays a particular form, returns its window handle. 
 1587   
 1588          @param pForm : pointer to form 
 1589          @param place : where has to be placed 
 1590          @param border : window manager decoration 
 1591          @param name : title of form 
 1592      """ 
 1593   
 1594      _fl_prepare_form_window = cfuncproto( 
 1595              load_so_libforms(), "fl_prepare_form_window", \ 
 1596              Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 
 1597              """Window fl_prepare_form_window(FL_FORM * form, int place, 
 1598                 int border, const char * name) 
 1599              """) 
 1600      iplace = convert_to_int(place) 
 1601      iborder = convert_to_int(border) 
 1602      sname = convert_to_string(name) 
 1603      keep_elem_refs(pForm, place, iplace, border, iborder, name, sname) 
 1604      retval = _fl_prepare_form_window(pForm, iplace, iborder, sname) 
 1605      return retval 
 1606   
 1607   
 1608 -def fl_show_form_window(pForm): 
 1609      """ 
 1610          fl_show_form_window(pForm) -> window ID 
 1611   
 1612          @param pForm : pointer to form 
 1613      """ 
 1614   
 1615      _fl_show_form_window = cfuncproto( 
 1616              load_so_libforms(), "fl_show_form_window", \ 
 1617              Window, [cty.POINTER(FL_FORM)], \ 
 1618              """Window fl_show_form_window(FL_FORM * form) 
 1619              """) 
 1620      keep_elem_refs(pForm) 
 1621      retval = _fl_show_form_window(pForm) 
 1622      return retval 
 1623   
 1624   
 1625 -def fl_adjust_form_size(pForm): 
 1626      """ 
 1627          fl_adjust_form_size(pForm) -> max_factor id 
 1628   
 1629          Similar to fl_fit_object_label, but will do it for all objects and 
 1630          has a smaller threshold. Mainly intended for compensation for font 
 1631          size variations. 
 1632   
 1633          @param pForm : pointer to form 
 1634      """ 
 1635   
 1636      _fl_adjust_form_size = cfuncproto( 
 1637              load_so_libforms(), "fl_adjust_form_size", \ 
 1638              cty.c_double, [cty.POINTER(FL_FORM)], \ 
 1639              """double fl_adjust_form_size(FL_FORM * form) 
 1640              """) 
 1641      keep_elem_refs(pForm) 
 1642      retval = _fl_adjust_form_size(pForm) 
 1643      return retval 
 1644   
 1645   
 1646 -def fl_form_is_visible(pForm): 
 1647      """ 
 1648          fl_form_is_visible(pForm) -> state id 
 1649   
 1650          Returns if form is visible. 
 1651   
 1652          @param pForm : pointer to form 
 1653      """ 
 1654   
 1655      _fl_form_is_visible = cfuncproto( 
 1656              load_so_libforms(), "fl_form_is_visible", \ 
 1657              cty.c_int, [cty.POINTER(FL_FORM)], \ 
 1658              """int fl_form_is_visible(FL_FORM * form) 
 1659              """) 
 1660      keep_elem_refs(pForm) 
 1661      retval = _fl_form_is_visible(pForm) 
 1662      return retval 
 1663   
 1664   
 1665 -def fl_form_is_iconified(pForm): 
 1666      """ 
 1667          fl_form_is_iconified(pForm) -> state id 
 1668   
 1669          Returns if a forms window is in iconified state. 
 1670   
 1671          @param pForm : pointer to form 
 1672      """ 
 1673   
 1674      _fl_form_is_iconified = cfuncproto( 
 1675              load_so_libforms(), "fl_form_is_iconified", \ 
 1676              cty.c_int, [cty.POINTER(FL_FORM)], \ 
 1677              """int fl_form_is_iconified(FL_FORM * form) 
 1678              """) 
 1679      keep_elem_refs(pForm) 
 1680      retval = _fl_form_is_iconified(pForm) 
 1681      return retval 
 1682   
 1683   
 1684  #already defined in xfdata 
 1685  #FL_RAW_CALLBACK = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 
 1686   
 1687 -def fl_register_raw_callback(pForm, mask, py_RawCallback): 
 1688      """ 
 1689          fl_register_raw_callback(pForm, mask, py_RawCallback) -> old raw_callback func. 
 1690   
 1691          Register pre-emptive event handlers. 
 1692   
 1693          @param pForm : pointer to form 
 1694          @param mask : key/button/window event mask (press, release, motion, 
 1695             enter, leave etc..) 
 1696          @param py_RawCallback : python callback function, 
 1697             fn(pForm, ptr_void) -> num 
 1698      """ 
 1699   
 1700      _fl_register_raw_callback = cfuncproto( 
 1701              load_so_libforms(), "fl_register_raw_callback", \ 
 1702              FL_RAW_CALLBACK, [cty.POINTER(FL_FORM), cty.c_ulong, 
 1703              FL_RAW_CALLBACK], \ 
 1704              """FL_RAW_CALLBACK fl_register_raw_callback(FL_FORM * form, 
 1705                 long unsigned int mask, FL_RAW_CALLBACK rcb) 
 1706              """) 
 1707      ulmask = convert_to_ulong(mask) 
 1708      c_RawCallback = FL_RAW_CALLBACK(py_RawCallback) 
 1709      keep_cfunc_refs(c_RawCallback, py_RawCallback) 
 1710      keep_elem_refs(pForm, mask, ulmask) 
 1711      retval = _fl_register_raw_callback(pForm, ulmask, c_RawCallback) 
 1712      return retval 
 1713   
 1714   
 1715  fl_register_call_back = fl_register_raw_callback 
 1716   
 1717   
 1718 -def fl_bgn_group(): 
 1719      """ 
 1720          fl_bgn_group() -> pObject 
 1721   
 1722          Starts a group definition. 
 1723      """ 
 1724   
 1725      _fl_bgn_group = cfuncproto( 
 1726              load_so_libforms(), "fl_bgn_group", \ 
 1727              cty.POINTER(FL_OBJECT), [], \ 
 1728              """FL_OBJECT * fl_bgn_group() 
 1729              """) 
 1730      retval = _fl_bgn_group() 
 1731      return retval 
 1732   
 1733   
 1734 -def fl_end_group(): 
 1735      """ 
 1736          fl_end_group() 
 1737   
 1738          Ends a group definition. 
 1739      """ 
 1740   
 1741      _fl_end_group = cfuncproto( 
 1742              load_so_libforms(), "fl_end_group", \ 
 1743              None, [], \ 
 1744              """void fl_end_group() 
 1745              """) 
 1746      _fl_end_group() 
 1747   
 1748   
 1749 -def fl_addto_group(pGroup): 
 1750      """ 
 1751          fl_addto_group(pGroup) -> pForm 
 1752   
 1753          Reopens a group to allow addition of further objects. 
 1754   
 1755          @param pGroup : pointer to group object to reopen 
 1756      """ 
 1757   
 1758      _fl_addto_group = cfuncproto( 
 1759              load_so_libforms(), "fl_addto_group", \ 
 1760              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], \ 
 1761              """FL_OBJECT * fl_addto_group(FL_OBJECT * group) 
 1762              """) 
 1763      keep_elem_refs(pGroup) 
 1764      retval = _fl_addto_group(pGroup) 
 1765      return retval 
 1766   
 1767   
 1768  # Routines that deal with FL_OBJECTS 
 1769   
 1770   
 1771 -def fl_get_object_objclass(pObject): 
 1772      """ 
 1773          fl_get_object_objclass(pObject) -> objclass id 
 1774   
 1775          Return the objclass of an object. 
 1776   
 1777          @param pObject : pointer to object 
 1778      """ 
 1779   
 1780      _fl_get_object_objclass = cfuncproto( 
 1781              load_so_libforms(), "fl_get_object_obclass", \ 
 1782              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1783              """int fl_get_object_objclass(FL_OBJECT * obj) 
 1784              """) 
 1785      keep_elem_refs(pObject) 
 1786      retval = _fl_get_object_objclass(pObject) 
 1787      return retval 
 1788   
 1789   
 1790 -def fl_get_object_type(pObject): 
 1791      """ 
 1792          fl_get_object_type(pObject) -> type id 
 1793   
 1794          Return the type of an object. 
 1795   
 1796          @param pObject : pointer to object 
 1797      """ 
 1798   
 1799      _fl_get_object_type = cfuncproto( 
 1800              load_so_libforms(), "fl_get_object_type", \ 
 1801              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1802              """int fl_get_object_type(FL_OBJECT * obj) 
 1803              """) 
 1804      keep_elem_refs(pObject) 
 1805      retval = _fl_get_object_type(pObject) 
 1806      return retval 
 1807   
 1808   
 1809 -def fl_set_object_boxtype(pObject, boxtype): 
 1810      """ 
 1811          fl_set_object_boxtype(pObject, boxtype) 
 1812   
 1813          Sets the type of box of an object. 
 1814   
 1815          @param pObject : pointer to object 
 1816          @param boxtype : type of the box 
 1817      """ 
 1818   
 1819      _fl_set_object_boxtype = cfuncproto( 
 1820              load_so_libforms(), "fl_set_object_boxtype", \ 
 1821              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1822              """void fl_set_object_boxtype(FL_OBJECT * ob, int boxtype) 
 1823              """) 
 1824      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 1825      iboxtype = convert_to_int(boxtype) 
 1826      keep_elem_refs(pObject, boxtype, iboxtype) 
 1827      _fl_set_object_boxtype(pObject, iboxtype) 
 1828   
 1829   
 1830 -def fl_get_object_boxtype(pObject): 
 1831      """ 
 1832          fl_get_object_boxtype(pObject) -> boxtype id 
 1833   
 1834          Return the boxtype of an object. 
 1835   
 1836          @param pObject : pointer to object 
 1837      """ 
 1838   
 1839      _fl_get_object_boxtype = cfuncproto( 
 1840              load_so_libforms(), "fl_get_object_boxtype", \ 
 1841              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 1842              """int fl_get_object_boxtype(FL_OBJECT * obj) 
 1843              """) 
 1844      keep_elem_refs(pObject) 
 1845      retval = _fl_get_object_boxtype(pObject) 
 1846      return retval 
 1847   
 1848   
 1849 -def fl_set_object_bw(pObject, bw): 
 1850      """ 
 1851          fl_set_object_bw(pObject, bw) 
 1852   
 1853          Sets the borderwidth of an object. 
 1854   
 1855          @param pObject : pointer to object 
 1856          @param bw : borderwidth of object 
 1857      """ 
 1858   
 1859      _fl_set_object_bw = cfuncproto( 
 1860              load_so_libforms(), "fl_set_object_bw", \ 
 1861              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1862              """void fl_set_object_bw(FL_OBJECT * ob, int bw) 
 1863              """) 
 1864      ibw = convert_to_int(bw) 
 1865      keep_elem_refs(pObject, bw, ibw) 
 1866      _fl_set_object_bw(pObject, ibw) 
 1867   
 1868   
 1869  #def fl_get_object_bw(pObject, bw)       *API change* 
 1870 -def fl_get_object_bw(pObject): 
 1871      """ 
 1872          fl_get_object_bw(pObject) -> bw 
 1873   
 1874          Returns the borderwidth of an object. 
 1875   
 1876          @param pObject : pointer to object 
 1877      """ 
 1878   
 1879      _fl_get_object_bw = cfuncproto( 
 1880              load_so_libforms(), "fl_get_object_bw", \ 
 1881              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], \ 
 1882              """void fl_get_object_bw(FL_OBJECT * ob, int * bw) 
 1883              """) 
 1884      bw, pbw = make_int_and_pointer() 
 1885      keep_elem_refs(pObject, bw, pbw) 
 1886      _fl_get_object_bw(pObject, pbw) 
 1887      return bw 
 1888   
 1889   
 1890 -def fl_set_object_resize(pObject, what): 
 1891      """ 
 1892          fl_set_object_resize(pObject, what) 
 1893   
 1894          Sets the resize property of an object. 
 1895   
 1896          @param pObject : pointer to object 
 1897          @param what : resize property 
 1898      """ 
 1899   
 1900      _fl_set_object_resize = cfuncproto( 
 1901              load_so_libforms(), "fl_set_object_resize", \ 
 1902              None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 
 1903              """void fl_set_object_resize(FL_OBJECT * ob, unsigned int what) 
 1904              """) 
 1905      uiwhat = convert_to_uint(what) 
 1906      keep_elem_refs(pObject, what, uiwhat) 
 1907      _fl_set_object_resize(pObject, uiwhat) 
 1908   
 1909   
 1910  #def fl_get_object_resize(pObject, what)       *API change* 
 1911 -def fl_get_object_resize(pObject): 
 1912      """ 
 1913          fl_get_object_resize(pObject) -> what 
 1914   
 1915          Returns the resize property of an object. 
 1916   
 1917          @param pObject : pointer to object 
 1918      """ 
 1919   
 1920      _fl_get_object_resize = cfuncproto( 
 1921              load_so_libforms(), "fl_get_object_resize", \ 
 1922               None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], \ 
 1923              """void fl_get_object_resize(FL_OBJECT * ob, unsigned int * what) 
 1924              """) 
 1925      what, pwhat = make_uint_and_pointer() 
 1926      keep_elem_refs(pObject, what, pwhat) 
 1927      _fl_get_object_resize(pObject, pwhat) 
 1928      return what 
 1929   
 1930   
 1931 -def fl_set_object_gravity(pObject, nw, se): 
 1932      """ 
 1933          fl_set_object_gravity(pObject, nw, se) 
 1934   
 1935          Sets the gravity properties of an object. 
 1936   
 1937          @param pObject : pointer to object 
 1938          @param nw : gravity property for NorthWest 
 1939          @param se : gravity property for SouthEast 
 1940      """ 
 1941   
 1942      _fl_set_object_gravity = cfuncproto( 
 1943              load_so_libforms(), "fl_set_object_gravity", \ 
 1944              None, [cty.POINTER(FL_OBJECT), cty.c_uint, cty.c_uint], \ 
 1945              """void fl_set_object_gravity(FL_OBJECT * ob, unsigned int nw, 
 1946                 unsigned int se) 
 1947              """) 
 1948      uinw = convert_to_uint(nw) 
 1949      uise = convert_to_uint(se) 
 1950      keep_elem_refs(pObject, nw, uinw, se, uise) 
 1951      _fl_set_object_gravity(pObject, uinw, uise) 
 1952   
 1953   
 1954  #def fl_get_object_gravity(pObject, nw, se)       *API change* 
 1955 -def fl_get_object_gravity(pObject): 
 1956      """ 
 1957          fl_get_object_gravity(pObject) -> nw, se 
 1958   
 1959          Returns the gravity properties of an object. 
 1960   
 1961          @param pObject : pointer to object 
 1962      """ 
 1963   
 1964      _fl_get_object_gravity = cfuncproto( 
 1965              load_so_libforms(), "fl_get_object_gravity", \ 
 1966              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint), 
 1967              cty.POINTER(cty.c_uint)], \ 
 1968              """void fl_get_object_gravity(FL_OBJECT * ob, unsigned int * nw, 
 1969                 unsigned int * se) 
 1970              """) 
 1971      nw, pnw = make_uint_and_pointer() 
 1972      se, pse = make_uint_and_pointer() 
 1973      keep_elem_refs(pObject, nw, se, pnw, pse) 
 1974      _fl_get_object_gravity(pObject, pnw, pse) 
 1975      return nw, se 
 1976   
 1977   
 1978 -def fl_set_object_lsize(pObject, lsize): 
 1979      """ 
 1980          fl_set_object_lsize(pObject, lsize) 
 1981   
 1982          Sets the label size of an object. 
 1983   
 1984          @param pObject : pointer to object 
 1985          @param lsize : label size 
 1986      """ 
 1987   
 1988      _fl_set_object_lsize = cfuncproto( 
 1989              load_so_libforms(), "fl_set_object_lsize", \ 
 1990              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 1991              """void fl_set_object_lsize(FL_OBJECT * ob, int lsize) 
 1992              """) 
 1993      ilsize = convert_to_int(lsize) 
 1994      keep_elem_refs(pObject, lsize, ilsize) 
 1995      _fl_set_object_lsize(pObject, ilsize) 
 1996   
 1997   
 1998 -def fl_get_object_lsize(pObject): 
 1999      """ 
 2000          fl_get_object_lsize(pObject) -> lsize num. 
 2001   
 2002          Returns the label size of an object. 
 2003   
 2004          @param pObject : pointer to object 
 2005      """ 
 2006   
 2007      _fl_get_object_lsize = cfuncproto( 
 2008              load_so_libforms(), "fl_get_object_lsize", \ 
 2009              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2010              """int fl_get_object_lsize(FL_OBJECT * obj) 
 2011              """) 
 2012      keep_elem_refs(pObject) 
 2013      retval = _fl_get_object_lsize(pObject) 
 2014      return retval 
 2015   
 2016   
 2017 -def fl_set_object_lstyle(pObject, lstyle): 
 2018      """ 
 2019          fl_set_object_lstyle(pObject, lstyle) 
 2020   
 2021          Sets the label style of an object. 
 2022   
 2023          @param pObject : pointer to object 
 2024          @param lstyle : label style 
 2025      """ 
 2026   
 2027      _fl_set_object_lstyle = cfuncproto( 
 2028              load_so_libforms(), "fl_set_object_lstyle", \ 
 2029              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2030              """void fl_set_object_lstyle(FL_OBJECT * ob, int lstyle) 
 2031              """) 
 2032      check_admitted_listvalues(lstyle, TEXTSTYLE_list) 
 2033      ilstyle = convert_to_int(lstyle) 
 2034      keep_elem_refs(pObject, lstyle, ilstyle) 
 2035      _fl_set_object_lstyle(pObject, ilstyle) 
 2036   
 2037   
 2038 -def fl_get_object_lstyle(pObject): 
 2039      """ 
 2040          fl_get_object_lstyle(pObject) -> lstyle num. 
 2041   
 2042          Returns the label style of an object. 
 2043   
 2044          @param pObject : pointer to object 
 2045      """ 
 2046   
 2047      _fl_get_object_lstyle = cfuncproto( 
 2048              load_so_libforms(), "fl_get_object_lstyle", \ 
 2049              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2050              """int fl_get_object_lstyle(FL_OBJECT * obj) 
 2051              """) 
 2052      keep_elem_refs(pObject) 
 2053      retval = _fl_get_object_lstyle(pObject) 
 2054      return retval 
 2055   
 2056   
 2057 -def fl_set_object_lcol(pObject, lcolr): 
 2058      """ 
 2059          fl_set_object_lcol(pObject, lcolr) 
 2060   
 2061          Sets the label color of an object. 
 2062   
 2063          @param pObject : pointer to object 
 2064          @param lcolr : label color 
 2065      """ 
 2066   
 2067      _fl_set_object_lcol = cfuncproto( 
 2068              load_so_libforms(), "fl_set_object_lcol", \ 
 2069              None, [cty.POINTER(FL_OBJECT), FL_COLOR], \ 
 2070              """void fl_set_object_lcol(FL_OBJECT * ob, FL_COLOR lcol) 
 2071              """) 
 2072      check_admitted_listvalues(lcolr, COLOR_list) 
 2073      ullcolr = convert_to_FL_COLOR(lcolr) 
 2074      keep_elem_refs(pObject, lcolr, ullcolr) 
 2075      _fl_set_object_lcol(pObject, ullcolr) 
 2076   
 2077   
 2078 -def fl_get_object_lcol(pObject): 
 2079      """ 
 2080          fl_get_object_lcol(pObject) -> color 
 2081   
 2082          Returns the label color of an object. 
 2083   
 2084          @param pObject : pointer to object 
 2085      """ 
 2086   
 2087      _fl_get_object_lcol = cfuncproto( 
 2088              load_so_libforms(), "fl_get_object_lcol", \ 
 2089              FL_COLOR, [cty.POINTER(FL_OBJECT)], \ 
 2090              """FL_COLOR fl_set_object_lcol(FL_OBJECT * obj) 
 2091              """) 
 2092      keep_elem_refs(pObject) 
 2093      retval = _fl_get_object_lcol(pObject) 
 2094      return retval 
 2095   
 2096   
 2097 -def fl_set_object_return(pObject, when): 
 2098      """ 
 2099          fl_set_object_return(pObject, when) -> ID num 
 2100   
 2101          Function for setting the conditions under which an object gets 
 2102          returned (or its callback invoked). If the object has to do 
 2103          additional work on setting te condition (e.g. it has child 
 2104          objects that also need to be set) it has to set up it's own 
 2105          function that then will called in the end. This function should 
 2106          only be called once an object has been created completely! 
 2107   
 2108          @param pObject : pointer to object 
 2109          @param when : return type 
 2110      """ 
 2111   
 2112      _fl_set_object_return = cfuncproto( 
 2113              load_so_libforms(), "fl_set_object_return", \ 
 2114              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2115              """int fl_set_object_return(FL_OBJECT * ob, int when)   DEPRECATED 
 2116              """) 
 2117      check_admitted_listvalues(when, RETURN_list) 
 2118      iwhen = convert_to_int(when) 
 2119      keep_elem_refs(pObject, when, iwhen) 
 2120      retval = _fl_set_object_return(pObject, iwhen) 
 2121      return retval 
 2122   
 2123   
 2124 -def fl_notify_object(pObject, cause): 
 2125      """ 
 2126          fl_notify_object(pObject, cause) 
 2127   
 2128          @param pObject : pointer to object 
 2129          @param cause : ? 
 2130      """ 
 2131   
 2132      _fl_notify_object = cfuncproto( 
 2133              load_so_libforms(), "fl_notify_object", \ 
 2134              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2135              """void fl_notify_object(FL_OBJECT * obj, int cause) 
 2136              """) 
 2137      icause = convert_to_int(cause) 
 2138      keep_elem_refs(pObject, cause, icause) 
 2139      _fl_notify_object(pObject, icause) 
 2140   
 2141   
 2142 -def fl_set_object_lalign(pObject, align): 
 2143      """ 
 2144          fl_set_object_lalign(pObject, align) 
 2145   
 2146          Sets alignment of an object. 
 2147   
 2148          @param pObject : pointer to object 
 2149          @param align : alignment of object 
 2150      """ 
 2151   
 2152      _fl_set_object_lalign = cfuncproto( 
 2153              load_so_libforms(), "fl_set_object_lalign", \ 
 2154              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2155              """void fl_set_object_lalign(FL_OBJECT * ob, int align) 
 2156              """) 
 2157      check_admitted_listvalues(align, ALIGN_list) 
 2158      ialign = convert_to_int(align) 
 2159      keep_elem_refs(pObject, align, ialign) 
 2160      _fl_set_object_lalign(pObject, ialign) 
 2161   
 2162   
 2163 -def fl_get_object_lalign(pObject): 
 2164      """ 
 2165          fl_get_object_lalign(pObject) -> align num. 
 2166   
 2167          Returns alignment of an object. 
 2168   
 2169          @param pObject : pointer to object 
 2170      """ 
 2171   
 2172      _fl_get_object_lalign = cfuncproto( 
 2173              load_so_libforms(), "fl_get_object_lalign", \ 
 2174              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2175              """int fl_set_object_lalign(FL_OBJECT * ob) 
 2176              """) 
 2177      keep_elem_refs(pObject) 
 2178      retval = _fl_get_object_lalign(pObject) 
 2179      return retval 
 2180   
 2181   
 2182 -def fl_set_object_shortcut(pObject, sstr, showit): 
 2183      """ 
 2184          fl_set_object_shortcut(pObject, sstr, showit) 
 2185   
 2186          @param pObject : pointer to object 
 2187          @param sstr : shortcut string 
 2188          @param showit : flag (0|1) 
 2189      """ 
 2190   
 2191      _fl_set_object_shortcut = cfuncproto( 
 2192              load_so_libforms(), "fl_set_object_shortcut", \ 
 2193              None, [cty.POINTER(FL_OBJECT), STRING, cty.c_int], \ 
 2194              """void fl_set_object_shortcut(FL_OBJECT * obj, 
 2195                 const char * sstr, int showit) 
 2196              """) 
 2197      ssstr = convert_to_string(sstr) 
 2198      ishowit = convert_to_int(showit) 
 2199      keep_elem_refs(pObject, sstr, ssstr, showit, ishowit) 
 2200      _fl_set_object_shortcut(pObject, ssstr, ishowit) 
 2201   
 2202   
 2203 -def fl_set_object_shortcutkey(pObject, keysym): 
 2204      """ 
 2205          fl_set_object_shortcutkey(pObject, keysym) 
 2206   
 2207          @param pObject : pointer to object 
 2208          @param keysym : ? 
 2209      """ 
 2210   
 2211      _fl_set_object_shortcutkey = cfuncproto( 
 2212              load_so_libforms(), "fl_set_object_shortcutkey", 
 2213              None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 
 2214              """void fl_set_object_shortcutkey(FL_OBJECT * obj, 
 2215                 unsigned int keysym) 
 2216              """) 
 2217      uikeysym = convert_to_uint(keysym) 
 2218      keep_elem_refs(pObject, keysym, uikeysym) 
 2219      _fl_set_object_shortcutkey(pObject, uikeysym) 
 2220   
 2221   
 2222 -def fl_set_object_dblbuffer(pObject, y): 
 2223      """ 
 2224          fl_set_object_dblbuffer(pObject, y) 
 2225   
 2226          @param pObject : pointer to object 
 2227          @param y : flag (0|1) to disable/enable double buffer 
 2228      """ 
 2229   
 2230      _fl_set_object_dblbuffer = cfuncproto( 
 2231              load_so_libforms(), "fl_set_object_dblbuffer", \ 
 2232              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2233              """void fl_set_object_dblbuffer(FL_OBJECT * ob, int y) 
 2234              """) 
 2235      iy = convert_to_int(y) 
 2236      keep_elem_refs(pObject, y, iy) 
 2237      _fl_set_object_dblbuffer(pObject, iy) 
 2238   
 2239   
 2240 -def fl_set_object_color(pObject, fgcolr, bgcolr): 
 2241      """ 
 2242          fl_set_object_color(pObject, fgcolr, bgcolr) 
 2243   
 2244          Sets the color of an object. 
 2245   
 2246          @param pObject : pointer to object 
 2247          @param fgcolr : foreground color 
 2248          @param bgcolr : background color 
 2249      """ 
 2250   
 2251      _fl_set_object_color = cfuncproto( 
 2252              load_so_libforms(), "fl_set_object_color", \ 
 2253              None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], \ 
 2254              """void fl_set_object_color(FL_OBJECT * ob, FL_COLOR col1, 
 2255                 FL_COLOR col2) 
 2256              """) 
 2257      check_admitted_listvalues(fgcolr, COLOR_list) 
 2258      check_admitted_listvalues(bgcolr, COLOR_list) 
 2259      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
 2260      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
 2261      keep_elem_refs(pObject, fgcolr, ulfgcolr, bgcolr, ulbgcolr) 
 2262      _fl_set_object_color(pObject, ulfgcolr, ulbgcolr) 
 2263   
 2264   
 2265  #def fl_set_object_color(pObject, fgcolr, bgcolr)  *API change* 
 2266 -def fl_get_object_color(pObject): 
 2267      """ 
 2268          fl_set_object_color(pObject) -> fgcolr, bgcolr 
 2269   
 2270          Returns the foreground and background colors of an object. 
 2271   
 2272          @param pObject : pointer to object 
 2273      """ 
 2274   
 2275      _fl_get_object_color = cfuncproto( 
 2276              load_so_libforms(), "fl_get_object_color", \ 
 2277              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), \ 
 2278              cty.POINTER(FL_COLOR)], \ 
 2279              """void fl_get_object_color(FL_OBJECT * ob, FL_COLOR * col1, 
 2280                 FL_COLOR * col2) 
 2281              """) 
 2282      fgcolr, pfgcolr = make_FL_COLOR_and_pointer() 
 2283      bgcolr, pbgcolr = make_FL_COLOR_and_pointer() 
 2284      keep_elem_refs(pObject, fgcolr, pfgcolr, bgcolr, pbgcolr) 
 2285      _fl_get_object_color(pObject, pfgcolr, pbgcolr) 
 2286      return fgcolr, bgcolr 
 2287   
 2288   
 2289 -def fl_set_object_label(pObject, label): 
 2290      """ 
 2291          fl_set_object_label(pObject, label) 
 2292   
 2293          Sets the label of an object. 
 2294   
 2295          @param pObject : pointer to object 
 2296          @param label : label of object 
 2297      """ 
 2298   
 2299      _fl_set_object_label = cfuncproto( 
 2300              load_so_libforms(), "fl_set_object_label", \ 
 2301              None, [cty.POINTER(FL_OBJECT), STRING], \ 
 2302              """void fl_set_object_label(FL_OBJECT * ob, const char * label) 
 2303              """) 
 2304      slabel = convert_to_string(label) 
 2305      keep_elem_refs(pObject, label, slabel) 
 2306      _fl_set_object_label(pObject, slabel) 
 2307   
 2308   
 2309 -def fl_get_object_label(pObject): 
 2310      """ 
 2311          fl_get_object_label(pObject) -> label 
 2312   
 2313          Returns the label of an object. 
 2314   
 2315          @param pObject : pointer to object 
 2316      """ 
 2317   
 2318      _fl_get_object_label = cfuncproto( 
 2319              load_so_libforms(), "fl_get_object_label", \ 
 2320              STRING, [cty.POINTER(FL_OBJECT)], \ 
 2321              """const char * fl_set_object_label(FL_OBJECT * obj) 
 2322              """) 
 2323      keep_elem_refs(pObject) 
 2324      retval = _fl_get_object_label(pObject) 
 2325      return retval 
 2326   
 2327   
 2328 -def fl_set_object_helper(pObject, tip): 
 2329      """ 
 2330          fl_set_object_helper(pObject, tip) 
 2331   
 2332          Sets the tooltip of an object. 
 2333   
 2334          @param pObject : pointer to object 
 2335          @param tip : tooltip text for object 
 2336      """ 
 2337   
 2338      _fl_set_object_helper = cfuncproto( 
 2339              load_so_libforms(), "fl_set_object_helper", \ 
 2340              None, [cty.POINTER(FL_OBJECT), STRING], \ 
 2341              """void fl_set_object_helper(FL_OBJECT * ob, const char * tip) 
 2342              """) 
 2343      stip = convert_to_string(tip) 
 2344      keep_elem_refs(pObject, tip, stip) 
 2345      _fl_set_object_helper(pObject, stip) 
 2346   
 2347   
 2348 -def fl_set_object_position(pObject, x, y): 
 2349      """ 
 2350          fl_set_object_position(pObject, x, y) 
 2351   
 2352          Sets position of an object. 
 2353   
 2354          @param pObject : pointer of object 
 2355          @param x : horizontal position 
 2356          @param y : vertical position 
 2357      """ 
 2358   
 2359      _fl_set_object_position = cfuncproto( 
 2360              load_so_libforms(), "fl_set_object_position", \ 
 2361              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2362              """void fl_set_object_position(FL_OBJECT * obj, FL_Coord x, 
 2363                 FL_Coord y) 
 2364              """) 
 2365      ix = convert_to_FL_Coord(x) 
 2366      iy = convert_to_FL_Coord(y) 
 2367      keep_elem_refs(pObject, x, ix, y, iy) 
 2368      _fl_set_object_position(pObject, ix, iy) 
 2369   
 2370   
 2371  #def fl_get_object_size(pObject, w, h)  *API change* 
 2372 -def fl_get_object_size(pObject): 
 2373      """ 
 2374          fl_get_object_size(pObject) -> width, height 
 2375   
 2376          Returns the size of an object. 
 2377   
 2378          @param pObject : pointer to object 
 2379      """ 
 2380   
 2381      _fl_get_object_size = cfuncproto( 
 2382              load_so_libforms(), "fl_get_object_size", \ 
 2383              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 2384              cty.POINTER(FL_Coord)], \ 
 2385              """void fl_get_object_size(FL_OBJECT * obj, FL_Coord * w, 
 2386                 FL_Coord * h) 
 2387              """) 
 2388      w, pw = make_FL_Coord_and_pointer() 
 2389      h, ph = make_FL_Coord_and_pointer() 
 2390      keep_elem_refs(pObject, w, h, pw, ph) 
 2391      _fl_get_object_size(pObject, pw, ph) 
 2392      return w, h 
 2393   
 2394   
 2395 -def fl_set_object_size(pObject, w, h): 
 2396      """ 
 2397          fl_set_object_size(pObject, w, h) 
 2398   
 2399          Sets the size of an object. 
 2400   
 2401          @param pObject : pointer to object 
 2402          @param w : width of object 
 2403          @param h : height of object 
 2404      """ 
 2405   
 2406      _fl_set_object_size = cfuncproto( 
 2407              load_so_libforms(), "fl_set_object_size", \ 
 2408              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2409              """void fl_set_object_size(FL_OBJECT * obj, FL_Coord w, 
 2410                 FL_Coord h) 
 2411              """) 
 2412      iw = convert_to_FL_Coord(w) 
 2413      ih = convert_to_FL_Coord(h) 
 2414      keep_elem_refs(pObject, w, iw, h, ih) 
 2415      _fl_set_object_size(pObject, iw, ih) 
 2416   
 2417   
 2418 -def fl_set_object_automatic(pObject, flag): 
 2419      """ 
 2420          fl_set_object_automatic(pObject, flag) 
 2421   
 2422          @param pObject : pointer to object 
 2423          @param flag : flag (0|1) 
 2424      """ 
 2425   
 2426      _fl_set_object_automatic = cfuncproto( 
 2427              load_so_libforms(), "fl_set_object_automatic", 
 2428              None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 
 2429              """void fl_set_object_automatic(FL_OBJECT * ob, int flag) 
 2430              """) 
 2431      iflag = convert_to_int(flag) 
 2432      keep_elem_refs(pObject, flag, iflag) 
 2433      _fl_set_object_automatic(pObject, iflag) 
 2434   
 2435   
 2436 -def fl_object_is_automatic(pObject): 
 2437      """ 
 2438          fl_object_is_automatic(pObject) -> flag num. 
 2439   
 2440          @param pObject : pointer to object 
 2441      """ 
 2442   
 2443      _fl_object_is_automatic = cfuncproto( 
 2444              load_so_libforms(), "fl_object_is_automatic", 
 2445              cty.c_int, [cty.POINTER(FL_OBJECT)], \ 
 2446              """int fl_object_is_automatic(FL_OBJECT * obj) 
 2447              """) 
 2448      keep_elem_refs(pObject) 
 2449      retval = _fl_object_is_automatic(pObject) 
 2450      return retval 
 2451   
 2452   
 2453 -def fl_draw_object_label(pObject): 
 2454      """ 
 2455          fl_draw_object_label(pObject) 
 2456   
 2457          @param pObject : pointer to object 
 2458      """ 
 2459   
 2460      _fl_draw_object_label = cfuncproto( 
 2461              load_so_libforms(), "fl_draw_object_label", \ 
 2462              None, [cty.POINTER(FL_OBJECT)], \ 
 2463              """void fl_draw_object_label(FL_OBJECT * ob) 
 2464              """) 
 2465      keep_elem_refs(pObject) 
 2466      _fl_draw_object_label(pObject) 
 2467   
 2468   
 2469 -def fl_draw_object_label_outside(pObject): 
 2470      """ 
 2471          fl_draw_object_label_outside(pObject) 
 2472   
 2473          @param pObject : pointer to object 
 2474      """ 
 2475   
 2476      _fl_draw_object_label_outside = cfuncproto( 
 2477              load_so_libforms(), "fl_draw_object_label_outside", 
 2478              None, [cty.POINTER(FL_OBJECT)], \ 
 2479              """void fl_draw_object_label_outside(FL_OBJECT * ob) 
 2480              """) 
 2481      keep_elem_refs(pObject) 
 2482      _fl_draw_object_label_outside(pObject) 
 2483   
 2484   
 2485 -def fl_get_object_component(pObjectComposite, objclass, compontype, numb): 
 2486      """ fl_get_object_component(pObjectComposite, objclass, compontype, numb) -> pObject 
 2487      """ 
 2488   
 2489      _fl_get_object_component = cfuncproto( 
 2490              load_so_libforms(), "fl_get_object_component", 
 2491              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), cty.c_int, 
 2492              cty.c_int, cty.c_int], \ 
 2493              """FL_OBJECT * fl_get_object_component(FL_OBJECT * composite, 
 2494                 int objclass, int type, int numb) 
 2495              """) 
 2496      iobjclass = convert_to_int(objclass) 
 2497      icompontype = convert_to_int(compontype) 
 2498      inumb = convert_to_int(numb) 
 2499      keep_elem_refs(pObjectComposite, objclass, iobjclass, compontype, \ 
 2500                     icompontype, numb, inumb) 
 2501      retval = _fl_get_object_component(pObjectComposite, iobjclass, \ 
 2502                                        icompontype, inumb) 
 2503      return retval 
 2504   
 2505   
 2506  # cfunction for _fl_for_all_objects 
 2507  cfunc_int_pobject_pvoid = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), \ 
 2508                                          cty.c_void_p) 
 2509   
 2510 -def fl_for_all_objects(pForm, py_cb, v): 
 2511      """ 
 2512          fl_for_all_objects(pForm, py_cb, v) 
 2513   
 2514          @param pForm : pointer to form 
 2515          @param py_cb : python function, fn(pObject, ptr_void) -> num. 
 2516          @param v : argument 
 2517      """ 
 2518   
 2519      _fl_for_all_objects = cfuncproto( 
 2520              load_so_libforms(), "fl_for_all_objects", \ 
 2521              None, [cty.POINTER(FL_FORM), cfunc_int_pobject_pvoid, \ 
 2522              cty.c_void_p], \ 
 2523              """void fl_for_all_objects(FL_FORM * form, int ( * cb ) \ 
 2524                 ( FL_OBJECT *, void * ), void * v) 
 2525              """) 
 2526      c_cb = cfunc_int_pobject_pvoid(py_cb) 
 2527      pv = cty.cast(v, cty.c_void_p) 
 2528      keep_cfunc_refs(c_cb, py_cb) 
 2529      keep_elem_refs(pForm, v, pv) 
 2530      _fl_for_all_objects(pForm, c_cb, pv) 
 2531   
 2532   
 2533  fl_draw_object_outside_label = fl_draw_object_label_outside 
 2534   
 2535   
 2536 -def fl_set_object_dblclick(pObject, timeout): 
 2537      """ 
 2538          fl_set_object_dblclick(pObject, timeout) 
 2539   
 2540          Sets double click timeout value of an object. 
 2541   
 2542          @param pObject : pointer to object 
 2543          @param timeout : timeout value for double click 
 2544      """ 
 2545   
 2546      _fl_set_object_dblclick = cfuncproto( 
 2547              load_so_libforms(), "fl_set_object_dblclick", \ 
 2548              None, [cty.POINTER(FL_OBJECT), cty.c_ulong], \ 
 2549              """void fl_set_object_dblclick(FL_OBJECT *obj, unsigned \ 
 2550                 long timeout) 
 2551              """) 
 2552      ultimeout = convert_to_ulong(timeout) 
 2553      keep_elem_refs(pObject, timeout, ultimeout) 
 2554      _fl_set_object_dblclick(pObject, ultimeout) 
 2555   
 2556   
 2557 -def fl_get_object_dblclick(pObject): 
 2558      """ 
 2559          fl_get_object_dblclick(pObject) -> timeout value 
 2560   
 2561          Return double click timeout value of an object. 
 2562   
 2563          @param pObject : pointer to object 
 2564      """ 
 2565   
 2566      _fl_get_object_dblclick = cfuncproto( 
 2567              load_so_libforms(), "fl_get_object_dblclick", \ 
 2568              cty.c_ulong, [cty.POINTER(FL_OBJECT)], \ 
 2569              """unsigned long fl_get_object_dblclick(FL_OBJECT *obj) 
 2570              """) 
 2571      keep_elem_refs(pObject) 
 2572      retval = _fl_get_object_dblclick(pObject) 
 2573      return retval 
 2574   
 2575   
 2576 -def fl_set_object_geometry(pObject, x, y, w, h): 
 2577      """ 
 2578          fl_set_object_geometry(pObject, x, y, w, h) 
 2579   
 2580          Sets the geometry (position and size) of an object. 
 2581   
 2582          @param pObject : pointer to object 
 2583          @param x : horizontal position (upper-left corner) 
 2584          @param y : vertical position (upper-left corner) 
 2585          @param w : width of the object in pixels 
 2586          @param h : height of the object in pixels 
 2587      """ 
 2588   
 2589      _fl_set_object_geometry = cfuncproto( 
 2590              load_so_libforms(), "fl_set_object_geometry", \ 
 2591              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord, FL_Coord, 
 2592              FL_Coord], \ 
 2593              """void fl_set_object_geometry(FL_OBJECT * obj, FL_Coord x, 
 2594              FL_Coord y, FL_Coord w, FL_Coord h) 
 2595              """) 
 2596      ix = convert_to_FL_Coord(x) 
 2597      iy = convert_to_FL_Coord(y) 
 2598      iw = convert_to_FL_Coord(w) 
 2599      ih = convert_to_FL_Coord(h) 
 2600      keep_elem_refs(pObject, x, ix, y, iy, w, iw, h, ih) 
 2601      _fl_set_object_geometry(pObject, ix, iy, iw, ih) 
 2602   
 2603   
 2604 -def fl_move_object(pObject, dx, dy): 
 2605      """ 
 2606          fl_move_object(pObject, dx, dy) 
 2607   
 2608          @param pObject : pointer to object 
 2609      """ 
 2610   
 2611      _fl_move_object = cfuncproto( 
 2612              load_so_libforms(), "fl_move_object", \ 
 2613              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 
 2614              """void fl_move_object(FL_OBJECT * obj, FL_Coord dx, FL_Coord dy) 
 2615              """) 
 2616      idx = convert_to_int(dx) 
 2617      idy = convert_to_int(dy) 
 2618      keep_elem_refs(pObject, dx, idx, dy, idy) 
 2619      _fl_move_object(pObject, idx, idy) 
 2620   
 2621   
 2622  fl_set_object_lcolor = fl_set_object_lcol 
 2623   
 2624   
 2625 -def fl_fit_object_label(pObject, xmargin, ymargin): 
 2626      """ 
 2627          fl_fit_object_label(pObject, xmargin, ymargin) 
 2628   
 2629          Checks if the label of an object fits into it (after x- and 
 2630          y-margin have been added). If not, all objects and the form 
 2631          are enlarged by the necessary factor (but never by more than 
 2632          a factor of 1.5) 
 2633   
 2634          @param pObject : pointer to object 
 2635          @param xmargin : horizontal margin 
 2636          @param ymargin : vertical margin 
 2637      """ 
 2638   
 2639      _fl_fit_object_label = cfuncproto( 
 2640              load_so_libforms(), "fl_fit_object_label",\ 
 2641              None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord],\ 
 2642              """void fl_fit_object_label(FL_OBJECT * obj, FL_Coord xmargin, 
 2643                 FL_Coord ymargin) 
 2644              """) 
 2645      ixmargin = convert_to_int(xmargin) 
 2646      iymargin = convert_to_int(ymargin) 
 2647      keep_elem_refs(pObject, xmargin, ixmargin, ymargin, iymargin) 
 2648      _fl_fit_object_label(pObject, ixmargin, iymargin) 
 2649   
 2650   
 2651  #def fl_get_object_geometry(pObject, x, y, w, h)       *API change* 
 2652 -def fl_get_object_geometry(pObject): 
 2653      """ 
 2654          fl_get_object_geometry(pObject) -> hor-xpos, vert-ypos, width, height 
 2655   
 2656          Returns the geometry (position and size) of an object. 
 2657   
 2658          @param pObject : pointer to object 
 2659      """ 
 2660   
 2661      _fl_get_object_geometry = cfuncproto( 
 2662              load_so_libforms(), "fl_get_object_geometry",\ 
 2663          None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 
 2664          cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 2665          """void fl_get_object_geometry(FL_OBJECT * ob, FL_Coord * x, 
 2666             FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 2667          """) 
 2668      x, px = make_FL_Coord_and_pointer() 
 2669      y, py = make_FL_Coord_and_pointer() 
 2670      w, pw = make_FL_Coord_and_pointer() 
 2671      h, ph = make_FL_Coord_and_pointer() 
 2672      keep_elem_refs(pObject, x, px, y, py, w, pw, h, ph) 
 2673      _fl_get_object_geometry(pObject, px, py, pw, ph) 
 2674      return x, y, w,h 
 2675   
 2676   
 2677  #def fl_get_object_position(pObject, x, y)       *API change* 
 2678 -def fl_get_object_position(pObject): 
 2679      """ 
 2680          fl_get_object_position(pObject) -> xpos, ypos 
 2681   
 2682          Returns the position of an object. 
 2683   
 2684          @param pObject : pointer to object 
 2685      """ 
 2686   
 2687      _fl_get_object_position = cfuncproto( 
 2688              load_so_libforms(), "fl_get_object_position",\ 
 2689              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 2690              cty.POINTER(FL_Coord)],\ 
 2691              """void fl_get_object_position(FL_OBJECT * ob, FL_Coord * x, 
 2692                 FL_Coord * y) 
 2693              """) 
 2694      x, px = make_FL_Coord_and_pointer() 
 2695      y, py = make_FL_Coord_and_pointer() 
 2696      keep_elem_refs(pObject, x, px, y, py) 
 2697      _fl_get_object_position(pObject, px, py) 
 2698      return x,y 
 2699   
 2700   
 2701  # this one takes into account the label 
 2702   
 2703  #def fl_get_object_bbox(pObject, x, y, w, h)       *API change* 
 2704 -def fl_get_object_bbox(pObject): 
 2705      """ 
 2706          fl_get_object_bbox(pObject) -> x, y, w, h 
 2707   
 2708          @param pObject : pointer to object 
 2709      """ 
 2710   
 2711      _fl_get_object_bbox = cfuncproto( 
 2712              load_so_libforms(), "fl_get_object_bbox",\ 
 2713              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 
 2714              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 2715              cty.POINTER(FL_Coord)],\ 
 2716              """void fl_get_object_bbox(FL_OBJECT * obj, FL_Coord * x, 
 2717                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 2718              """) 
 2719      x, px = make_FL_Coord_and_pointer() 
 2720      y, py = make_FL_Coord_and_pointer() 
 2721      w, pw = make_FL_Coord_and_pointer() 
 2722      h, ph = make_FL_Coord_and_pointer() 
 2723      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
 2724      _fl_get_object_bbox(pObject, px, py, pw, ph) 
 2725      return x, y, w,h 
 2726   
 2727   
 2728  fl_compute_object_geometry = fl_get_object_bbox 
 2729   
 2730   
 2731 -def fl_call_object_callback(pObject): 
 2732      """ 
 2733          fl_call_object_callback(pObject) 
 2734   
 2735          @param pObject : pointer to object 
 2736      """ 
 2737   
 2738      _fl_call_object_callback = cfuncproto( 
 2739              load_so_libforms(), "fl_call_object_callback",\ 
 2740              None, [cty.POINTER(FL_OBJECT)],\ 
 2741              """void fl_call_object_callback(FL_OBJECT * ob) 
 2742              """) 
 2743      keep_elem_refs(pObject) 
 2744      _fl_call_object_callback(pObject) 
 2745   
 2746   
 2747  #already defined in xfdata 
 2748  #FL_HANDLEPTR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), cty.c_int, \ 
 2749  #                FL_Coord, FL_Coord, cty.c_int, cty.c_void_p) 
 2750   
 2751 -def fl_set_object_prehandler(pObject, py_HandlerPtr): 
 2752      """ 
 2753          fl_set_object_prehandler(pObject, py_HandlerPtr) ->  pHandlerPtr 
 2754   
 2755          @param pObject : pointer to object 
 2756          @param py_HandlerPtr : python callback function, fn(pObject, 
 2757             num, coord, coord, num, ptr_void) -> num 
 2758      """ 
 2759   
 2760      _fl_set_object_prehandler = cfuncproto( 
 2761              load_so_libforms(), "fl_set_object_prehandler", 
 2762              FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 
 2763              """FL_HANDLEPTR fl_set_object_prehandler(FL_OBJECT * ob, 
 2764                 FL_HANDLEPTR phandler) 
 2765              """) 
 2766      c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 
 2767      keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 
 2768      keep_elem_refs(pObject) 
 2769      retval = _fl_set_object_prehandler(pObject, c_HandlerPtr) 
 2770      return retval 
 2771   
 2772   
 2773 -def fl_set_object_posthandler(pObject, py_HandlerPtr): 
 2774      """ 
 2775          fl_set_object_posthandler(pObject, py_HandlerPtr) -> pHandlerPtr 
 2776   
 2777          @param pObject : pointer to object 
 2778          @param py_HandlerPtr : python callback function, fn(pObject, 
 2779             num, coord, coord, num, ptr_void) -> num 
 2780      """ 
 2781   
 2782      _fl_set_object_posthandler = cfuncproto( 
 2783              load_so_libforms(), "fl_set_object_posthandler", 
 2784              FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 
 2785              """FL_HANDLEPTR fl_set_object_posthandler(FL_OBJECT * ob, 
 2786                 FL_HANDLEPTR post) 
 2787              """) 
 2788      c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 
 2789      keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 
 2790      keep_elem_refs(pObject) 
 2791      retval = _fl_set_object_posthandler(pObject, c_HandlerPtr) 
 2792      return retval 
 2793   
 2794   
 2795  #already defined in xfdata 
 2796  #FL_CALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_long) 
 2797   
 2798 -def fl_set_object_callback(pObject, py_CallbackPtr, argum): 
 2799      """ 
 2800          fl_set_object_callback(pObject, py_CallbackPtr, argum) -> c_callback func. 
 2801   
 2802          Calls a callback function bound to an object, if a condition is met. 
 2803   
 2804          @param pObject : pointer to object 
 2805          @param py_CallbackPtr : a python function with no () and no args to 
 2806             be used as callback, fn(pObject, longnum) 
 2807          @param argum : argument being passed to function 
 2808      """ 
 2809   
 2810      _fl_set_object_callback = cfuncproto( 
 2811              load_so_libforms(), "fl_set_object_callback",\ 
 2812              FL_CALLBACKPTR, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, 
 2813              cty.c_long], 
 2814              """FL_CALLBACKPTR fl_set_object_callback(FL_OBJECT * obj,\ 
 2815              FL_CALLBACKPTR callback, long int argument) 
 2816              """) 
 2817      largum = convert_to_long(argum) 
 2818      c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 
 2819      keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 
 2820      keep_elem_refs(pObject, argum, largum) 
 2821      retval = _fl_set_object_callback(pObject, c_CallbackPtr, largum) 
 2822      return retval 
 2823   
 2824   
 2825  fl_set_object_align = fl_set_object_lalign 
 2826  fl_set_call_back = fl_set_object_callback 
 2827   
 2828   
 2829 -def fl_redraw_object(pObject): 
 2830      """ 
 2831          fl_redraw_object(pObject) 
 2832   
 2833          @param pObject : pointer to object 
 2834      """ 
 2835   
 2836      _fl_redraw_object = cfuncproto( 
 2837              load_so_libforms(), "fl_redraw_object",\ 
 2838              None, [cty.POINTER(FL_OBJECT)],\ 
 2839              """void fl_redraw_object(FL_OBJECT * obj) 
 2840              """) 
 2841      keep_elem_refs(pObject) 
 2842      _fl_redraw_object(pObject) 
 2843   
 2844   
 2845 -def fl_scale_object(pObject, xs, ys): 
 2846      """ 
 2847          fl_scale_object(pObject, xs, ys) 
 2848   
 2849          Scales (shrink or enlarge) an object. 
 2850   
 2851          @param pObject : pointer to object 
 2852          @param xs : new horizontal factor 
 2853          @param ys : new vertical factor 
 2854      """ 
 2855   
 2856      _fl_scale_object = cfuncproto( 
 2857              load_so_libforms(), "fl_scale_object",\ 
 2858              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double],\ 
 2859              """void fl_scale_object(FL_OBJECT * ob, double xs, double ys) 
 2860              """) 
 2861      fxs = convert_to_double(xs) 
 2862      fys = convert_to_double(ys) 
 2863      keep_elem_refs(pObject, xs, fxs, ys, fys) 
 2864      _fl_scale_object(pObject, fxs, fys) 
 2865   
 2866   
 2867 -def fl_show_object(pObject): 
 2868      """ 
 2869          fl_show_object(pObject) 
 2870   
 2871          @param pObject : pointer to object 
 2872      """ 
 2873   
 2874      _fl_show_object = cfuncproto( 
 2875              load_so_libforms(), "fl_show_object",\ 
 2876              None, [cty.POINTER(FL_OBJECT)],\ 
 2877              """void fl_show_object(FL_OBJECT * ob) 
 2878              """) 
 2879      keep_elem_refs(pObject) 
 2880      _fl_show_object(pObject) 
 2881   
 2882   
 2883 -def fl_hide_object(pObject): 
 2884      """ 
 2885          fl_hide_object(pObject) 
 2886   
 2887          @param pObject : pointer to object 
 2888      """ 
 2889   
 2890      _fl_hide_object = cfuncproto( 
 2891              load_so_libforms(), "fl_hide_object",\ 
 2892              None, [cty.POINTER(FL_OBJECT)],\ 
 2893              """void fl_hide_object(FL_OBJECT * ob) 
 2894              """) 
 2895      keep_elem_refs(pObject) 
 2896      _fl_hide_object(pObject) 
 2897   
 2898   
 2899 -def fl_object_is_visible(pObject): 
 2900      """ 
 2901          fl_object_is_visible(pObject) -> num. 
 2902   
 2903          @param pObject : pointer to object 
 2904      """ 
 2905   
 2906      _fl_object_is_visible = cfuncproto( 
 2907              load_so_libforms(), "fl_object_is_visible",\ 
 2908              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 2909              """int fl_object_is_visible(FL_OBJECT * obj) 
 2910              """) 
 2911      keep_elem_refs(pObject) 
 2912      retval = _fl_object_is_visible(pObject) 
 2913      return retval 
 2914   
 2915   
 2916 -def fl_free_object(pObject): 
 2917      """ 
 2918          fl_free_object(pObject) 
 2919   
 2920          @param pObject : pointer to object 
 2921      """ 
 2922   
 2923      _fl_free_object = cfuncproto( 
 2924              load_so_libforms(), "fl_free_object",\ 
 2925              None, [cty.POINTER(FL_OBJECT)],\ 
 2926              """void fl_free_object(FL_OBJECT * obj) 
 2927              """) 
 2928      keep_elem_refs(pObject) 
 2929      _fl_free_object(pObject) 
 2930   
 2931   
 2932 -def fl_delete_object(pObject): 
 2933      """ 
 2934          fl_delete_object(pObject) 
 2935   
 2936          @param pObject : pointer to object 
 2937      """ 
 2938   
 2939      _fl_delete_object = cfuncproto( 
 2940              load_so_libforms(), "fl_delete_object",\ 
 2941              None, [cty.POINTER(FL_OBJECT)],\ 
 2942              """void fl_delete_object(FL_OBJECT * obj) 
 2943              """) 
 2944      keep_elem_refs(pObject) 
 2945      _fl_delete_object(pObject) 
 2946   
 2947   
 2948 -def fl_get_object_return_state(pObject): 
 2949      """ 
 2950          fl_get_object_return_state(pObject) -> ID num 
 2951   
 2952          @param pObject : pointer to object 
 2953      """ 
 2954   
 2955      _fl_get_object_return_state = cfuncproto( 
 2956              load_so_libforms(), "fl_get_object_return_state", 
 2957              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 2958              """int fl_get_object_return_state(FL_OBJECT * obj) 
 2959              """) 
 2960      keep_elem_refs(pObject) 
 2961      retval = _fl_get_object_return_state(pObject) 
 2962      return retval 
 2963   
 2964   
 2965 -def fl_trigger_object(pObject): 
 2966      """ 
 2967          fl_trigger_object(pObject) 
 2968   
 2969          @param pObject : pointer to object 
 2970      """ 
 2971   
 2972      _fl_trigger_object = cfuncproto( 
 2973              load_so_libforms(), "fl_trigger_object",\ 
 2974              None, [cty.POINTER(FL_OBJECT)],\ 
 2975              """void fl_trigger_object(FL_OBJECT * obj) 
 2976              """) 
 2977      keep_elem_refs(pObject) 
 2978      _fl_trigger_object(pObject) 
 2979   
 2980   
 2981 -def fl_activate_object(pObject): 
 2982      """ 
 2983          fl_activate_object(pObject) 
 2984   
 2985          @param pObject : pointer to object 
 2986      """ 
 2987   
 2988      _fl_activate_object = cfuncproto( 
 2989              load_so_libforms(), "fl_activate_object",\ 
 2990              None, [cty.POINTER(FL_OBJECT)],\ 
 2991              """void fl_activate_object(FL_OBJECT * ob) 
 2992              """) 
 2993      keep_elem_refs(pObject) 
 2994      _fl_activate_object(pObject) 
 2995   
 2996   
 2997 -def fl_deactivate_object(pObject): 
 2998      """ 
 2999          fl_deactivate_object(pObject) 
 3000   
 3001          @param pObject : pointer to object 
 3002      """ 
 3003   
 3004      _fl_deactivate_object = cfuncproto( 
 3005              load_so_libforms(), "fl_deactivate_object",\ 
 3006              None, [cty.POINTER(FL_OBJECT)],\ 
 3007              """void fl_deactivate_object(FL_OBJECT * ob) 
 3008              """) 
 3009      keep_elem_refs(pObject) 
 3010      _fl_deactivate_object(pObject) 
 3011   
 3012   
 3013 -def fl_object_is_active(pObject): 
 3014      """ 
 3015          fl_object_is_active(pObject) -> num. 
 3016   
 3017          Returns if object is active and reacts to event. 
 3018   
 3019          @param pObject : pointer to object 
 3020      """ 
 3021   
 3022      _fl_object_is_active = cfuncproto( 
 3023              load_so_libforms(), "fl_object_is_active",\ 
 3024              cty.c_int, [cty.POINTER(FL_OBJECT)],\ 
 3025              """int fl_object_is_active(FL_OBJECT * ob) 
 3026              """) 
 3027      keep_elem_refs(pObject) 
 3028      retval = _fl_object_is_active(pObject) 
 3029      return retval 
 3030   
 3031   
 3032  # cfunction for _fl_enumerate_fonts 
 3033  cfunc_none_string = cty.CFUNCTYPE(None, STRING) 
 3034   
 3035 -def fl_enumerate_fonts(py_output, shortform): 
 3036      """ fl_enumerate_fonts(py_output, shortform) -> ID num 
 3037      """ 
 3038   
 3039      _fl_enumerate_fonts = cfuncproto( 
 3040              load_so_libforms(), "fl_enumerate_fonts",\ 
 3041              cty.c_int, [cfunc_none_string, cty.c_int],\ 
 3042              """int fl_enumerate_fonts(void ( * output )( const char *s ), \ 
 3043                 int shortform) 
 3044              """) 
 3045      ishortform = convert_to_int(shortform) 
 3046      c_output = cfunc_none_string(py_output) 
 3047      keep_cfunc_refs(c_output, py_output) 
 3048      keep_elem_refs(shortform, ishortform) 
 3049      retval = _fl_enumerate_fonts(c_output, ishortform) 
 3050      return retval 
 3051   
 3052   
 3053 -def fl_set_font_name(n, name): 
 3054      """ fl_set_font_name(n, name) -> ID num 
 3055      """ 
 3056   
 3057      _fl_set_font_name = cfuncproto( 
 3058              load_so_libforms(), "fl_set_font_name",\ 
 3059              cty.c_int, [cty.c_int, STRING],\ 
 3060              """int fl_set_font_name(int n, const char * name) 
 3061              """) 
 3062      inum = convert_to_int(n) 
 3063      sname = convert_to_string(name) 
 3064      keep_elem_refs(n, inum, name, sname) 
 3065      retval = _fl_set_font_name(inum, sname) 
 3066      return retval 
 3067   
 3068   
 3069 -def fl_set_font(numb, size): 
 3070      """ fl_set_font(numb, size) 
 3071      """ 
 3072   
 3073      _fl_set_font = cfuncproto( 
 3074              load_so_libforms(), "fl_set_font",\ 
 3075              None, [cty.c_int, cty.c_int],\ 
 3076              """void fl_set_font(int numb, int size) 
 3077              """) 
 3078      inumb = convert_to_int(numb) 
 3079      isize = convert_to_int(size) 
 3080      keep_elem_refs(numb, inumb, size, isize) 
 3081      _fl_set_font(inumb, isize) 
 3082   
 3083   
 3084  # routines that facilitate free object 
 3085   
 3086  #def fl_get_char_height(style, size, asc, desc)       *API change* 
 3087 -def fl_get_char_height(style, size): 
 3088      """ fl_get_char_height(style, size) -> height num., asc, desc 
 3089      """ 
 3090   
 3091      _fl_get_char_height = cfuncproto( 
 3092              load_so_libforms(), "fl_get_char_height",\ 
 3093              cty.c_int, [cty.c_int, cty.c_int, cty.POINTER(cty.c_int), 
 3094              cty.POINTER(cty.c_int)],\ 
 3095              """int fl_get_char_height(int style, int size, int * asc, 
 3096                 int * desc) 
 3097              """) 
 3098      istyle = convert_to_int(style) 
 3099      isize = convert_to_int(size) 
 3100      asc, pasc = make_int_and_pointer()          # not sure 
 3101      desc, pdesc = make_int_and_pointer() 
 3102      keep_elem_refs(style, istyle, size, isize, asc, desc, pasc, pdesc) 
 3103      retval = _fl_get_char_height(istyle, isize, pasc, pdesc) 
 3104      return retval, asc, desc 
 3105   
 3106   
 3107 -def fl_get_char_width(style, size): 
 3108      """ fl_get_char_width(style, size) -> width num. 
 3109      """ 
 3110   
 3111      _fl_get_char_width = cfuncproto( 
 3112              load_so_libforms(), "fl_get_char_width",\ 
 3113              cty.c_int, [cty.c_int, cty.c_int],\ 
 3114              """int fl_get_char_width(int style, int size) 
 3115              """) 
 3116      istyle = convert_to_int(style) 
 3117      isize = convert_to_int(size) 
 3118      keep_elem_refs(style, istyle, size, isize) 
 3119      retval = _fl_get_char_width(istyle, isize) 
 3120      return retval 
 3121   
 3122   
 3123  #def fl_get_string_height(style, size, strng, strglen, asc, desc)       *API change* 
 3124 -def fl_get_string_height(style, size, strng, strglen): 
 3125      """ fl_get_string_height(style, size, strng, strglen) -> height num., asc, desc 
 3126      """ 
 3127   
 3128      _fl_get_string_height = cfuncproto( 
 3129              load_so_libforms(), "fl_get_string_height",\ 
 3130              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int, 
 3131              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3132              """int fl_get_string_height(int style, int size, const char * s, 
 3133                 int len, int * asc, int * desc) 
 3134              """) 
 3135      istyle = convert_to_int(style) 
 3136      isize = convert_to_int(size) 
 3137      sstrng = convert_to_string(strng) 
 3138      istrglen = convert_to_int(strglen) 
 3139      #pasc = cty.cast(asc, cty.POINTER(cty.c_int)) 
 3140      asc, pasc = make_int_and_pointer() 
 3141      #pdesc = cty.cast(desc, cty.POINTER(cty.c_int)) 
 3142      desc, pdesc = make_int_and_pointer() 
 3143      keep_elem_refs(style, istyle, size, isize, strng, sstrng, strglen,\ 
 3144                     istrglen, asc, desc, pasc, pdesc) 
 3145      retval = _fl_get_string_height(istyle, isize, sstrng, istrglen,\ 
 3146                                     pasc, pdesc) 
 3147      return retval, asc, desc 
 3148   
 3149   
 3150 -def fl_get_string_width(style, size, s, strglen): 
 3151      """ fl_get_string_width(style, size, s, strglen) -> width num. 
 3152      """ 
 3153   
 3154      _fl_get_string_width = cfuncproto( 
 3155              load_so_libforms(), "fl_get_string_width",\ 
 3156              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 
 3157              """int fl_get_string_width(int style, int size, const char * s, 
 3158                 int len) 
 3159              """) 
 3160      istyle = convert_to_int(style) 
 3161      isize = convert_to_int(size) 
 3162      ss = convert_to_string(s) 
 3163      istrglen = convert_to_int(strglen) 
 3164      keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 
 3165      retval = _fl_get_string_width(istyle, isize, ss, istrglen) 
 3166      return retval 
 3167   
 3168   
 3169 -def fl_get_string_widthTAB(style, size, s, strglen): 
 3170      """ fl_get_string_widthTAB(style, size, s, strglen) -> width num. 
 3171      """ 
 3172   
 3173      _fl_get_string_widthTAB = cfuncproto( 
 3174              load_so_libforms(), "fl_get_string_widthTAB",\ 
 3175              cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 
 3176              """int fl_get_string_widthTAB(int style, int size, const char * s, 
 3177                 int len) 
 3178              """) 
 3179      istyle = convert_to_int(style) 
 3180      isize = convert_to_int(size) 
 3181      ss = convert_to_string(s) 
 3182      istrglen = convert_to_int(strglen) 
 3183      keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 
 3184      retval = _fl_get_string_widthTAB(istyle, isize, ss, istrglen) 
 3185      return retval 
 3186   
 3187   
 3188  #def fl_get_string_dimension(fntstyle, fntsize, s, strglen, width, height)       *API change* 
 3189 -def fl_get_string_dimension(fntstyle, fntsize, s, strglen): 
 3190      """ fl_get_string_dimension(fntstyle, fntsize, s, strglen) -> width, height 
 3191      """ 
 3192   
 3193      _fl_get_string_dimension = cfuncproto( 
 3194              load_so_libforms(), "fl_get_string_dimension",\ 
 3195              None, [cty.c_int, cty.c_int, STRING, cty.c_int, 
 3196              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3197              """void fl_get_string_dimension(int fntstyle, int fntsize, 
 3198                 const char * s, int len, int * width, int * height) 
 3199              """) 
 3200      ifntstyle = convert_to_int(fntstyle) 
 3201      ifntsize = convert_to_int(fntsize) 
 3202      ss = convert_to_string(s) 
 3203      istrglen = convert_to_int(strglen) 
 3204      width, pwidth = make_int_and_pointer() 
 3205      height, pheight = make_int_and_pointer() 
 3206      keep_elem_refs(fntstyle, ifntstyle, fntsize, ifntsize, s, ss, strglen, 
 3207                     istrglen, width, height, pwidth, pheight) 
 3208      _fl_get_string_dimension(ifntstyle, ifntsize, ss, istrglen, pwidth, 
 3209                              pheight) 
 3210      return width, height 
 3211   
 3212   
 3213  fl_get_string_size = fl_get_string_dimension 
 3214   
 3215   
 3216  #def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff, xx, yy)       *API change* 
 3217 -def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff): 
 3218      """ fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff) -> xx, yy 
 3219      """ 
 3220   
 3221      _fl_get_align_xy = cfuncproto( 
 3222              load_so_libforms(), "fl_get_align_xy",\ 
 3223              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\ 
 3224              cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.POINTER(cty.c_int),\ 
 3225              cty.POINTER(cty.c_int)],\ 
 3226              """void fl_get_align_xy(int align, int x, int y, int w, int h, 
 3227              int xsize, int ysize, int xoff, int yoff, int * xx, int * yy) 
 3228              """) 
 3229      check_admitted_listvalues(align, ALIGN_list) 
 3230      ialign = convert_to_int(align) 
 3231      ix = convert_to_int(x) 
 3232      iy = convert_to_int(y) 
 3233      iw = convert_to_int(w) 
 3234      ih = convert_to_int(h) 
 3235      ixsize = convert_to_int(xsize) 
 3236      iysize = convert_to_int(ysize) 
 3237      ixoff = convert_to_int(xoff) 
 3238      iyoff = convert_to_int(yoff) 
 3239      xx, pxx = make_int_and_pointer() 
 3240      yy, pyy = make_int_and_pointer() 
 3241      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, xsize, ixsize, 
 3242                     ysize, iysize, xoff, ixoff, yoff, iyoff, xx, yy, pxx, pyy) 
 3243      _fl_get_align_xy(ialign, ix, iy, iw, ih, ixsize, iysize, ixoff, 
 3244                       iyoff, pxx, pyy) 
 3245      return xx, yy 
 3246   
 3247   
 3248 -def fl_drw_text(align, x, y, w, h, colr, style, size, txtstr): 
 3249      """ fl_drw_text(align, x, y, w, h, colr, style, size, txtstr) 
 3250      """ 
 3251   
 3252      _fl_drw_text = cfuncproto( 
 3253              load_so_libforms(), "fl_drw_text",\ 
 3254              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3255              cty.c_int, cty.c_int, STRING],\ 
 3256              """void fl_drw_text(int align, FL_Coord x, FL_Coord y, FL_Coord w, 
 3257                 FL_Coord h, FL_COLOR c, int style, int size, const char * istr) 
 3258              """) 
 3259      check_admitted_listvalues(align, ALIGN_list) 
 3260      ialign = convert_to_int(align) 
 3261      ix = convert_to_FL_Coord(x) 
 3262      iy = convert_to_FL_Coord(y) 
 3263      iw = convert_to_FL_Coord(w) 
 3264      ih = convert_to_FL_Coord(h) 
 3265      ulcolr = convert_to_FL_COLOR(colr) 
 3266      istyle = convert_to_int(style) 
 3267      isize = convert_to_int(size) 
 3268      s_txtstr = convert_to_string(txtstr) 
 3269      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3270                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 
 3271      _fl_drw_text(ialign, ix, iy, iw, ih, ulcolr, istyle, isize, 
 3272                   s_txtstr) 
 3273   
 3274   
 3275 -def fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr): 
 3276      """ fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr) 
 3277      """ 
 3278   
 3279      _fl_drw_text_beside = cfuncproto( 
 3280              load_so_libforms(), "fl_drw_text_beside",\ 
 3281              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3282              cty.c_int, cty.c_int, STRING],\ 
 3283              """void fl_drw_text_beside(int align, FL_Coord x, FL_Coord y, 
 3284                 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 
 3285                 const char * str) 
 3286              """) 
 3287      check_admitted_listvalues(align, ALIGN_list) 
 3288      ialign = convert_to_int(align) 
 3289      ix = convert_to_FL_Coord(x) 
 3290      iy = convert_to_FL_Coord(y) 
 3291      iw = convert_to_FL_Coord(w) 
 3292      ih = convert_to_FL_Coord(h) 
 3293      ulcolr = convert_to_FL_COLOR(colr) 
 3294      istyle = convert_to_int(style) 
 3295      isize = convert_to_int(size) 
 3296      s_txtstr = convert_to_string(txtstr) 
 3297      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3298                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 
 3299      _fl_drw_text_beside(ialign, ix, iy, iw, ih, ulcolr, istyle, 
 3300                          isize, s_txtstr) 
 3301   
 3302   
 3303 -def fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos): 
 3304      """ fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos) 
 3305      """ 
 3306   
 3307      _fl_drw_text_cursor = cfuncproto( 
 3308              load_so_libforms(), "fl_drw_text_cursor",\ 
 3309              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 3310              FL_COLOR, cty.c_int, cty.c_int, STRING, cty.c_int, cty.c_int],\ 
 3311              """void fl_drw_text_cursor(int align, FL_Coord x, FL_Coord y, 
 3312                 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 
 3313                 const char * str, int cc, int pos) 
 3314              """) 
 3315      check_admitted_listvalues(align, ALIGN_list) 
 3316      ialign = convert_to_int(align) 
 3317      ix = convert_to_FL_Coord(x) 
 3318      iy = convert_to_FL_Coord(y) 
 3319      iw = convert_to_FL_Coord(w) 
 3320      ih = convert_to_FL_Coord(h) 
 3321      ulcolr = convert_to_FL_COLOR(colr) 
 3322      istyle = convert_to_int(style) 
 3323      isize = convert_to_int(size) 
 3324      s_txtstr = convert_to_string(txtstr) 
 3325      icc = convert_to_int(cc) 
 3326      ipos = convert_to_int(pos) 
 3327      keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 
 3328                     ulcolr, style, istyle, size, isize, txtstr, s_txtstr, 
 3329                     cc, icc, pos, ipos) 
 3330      _fl_drw_text_cursor(ialign, ix, iy, iw, ih, ulcolr, istyle, 
 3331                          isize, s_txtstr, icc, ipos) 
 3332   
 3333   
 3334 -def fl_drw_box(style, x, y, w, h, colr, bwIn): 
 3335      """ fl_drw_box(style, x, y, w, h, colr, bwIn) 
 3336      """ 
 3337   
 3338      _fl_drw_box = cfuncproto( 
 3339              load_so_libforms(), "fl_drw_box",\ 
 3340              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 
 3341              cty.c_int],\ 
 3342              """void fl_drw_box(int style, FL_Coord x, FL_Coord y, FL_Coord w, 
 3343                 FL_Coord h, FL_COLOR c, int bw_in) 
 3344              """) 
 3345      istyle = convert_to_int(style) 
 3346      ix = convert_to_FL_Coord(x) 
 3347      iy = convert_to_FL_Coord(y) 
 3348      iw = convert_to_FL_Coord(w) 
 3349      ih = convert_to_FL_Coord(h) 
 3350      ulcolr = convert_to_FL_COLOR(colr) 
 3351      ibwIn = convert_to_int(bwIn) 
 3352      keep_elem_refs(style, istyle, x, ix, y, iy, w, iw, h, ih, colr, 
 3353                     ulcolr, bwIn, ibwIn) 
 3354      _fl_drw_box(style, x, y, w, h, ulcolr, ibwIn) 
 3355   
 3356   
 3357  FL_DRAWPTR = cty.CFUNCTYPE(None, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 3358                             cty.c_int, FL_COLOR) 
 3359   
 3360 -def fl_add_symbol(name, py_DrawPtr, scalable): 
 3361      """ 
 3362          fl_add_symbol(name, py_DrawPtr, scalable) -> num. 
 3363   
 3364          Adds a symbol. 
 3365   
 3366          @param name : name of a symbol 
 3367          @param py_DrawPtr : python function to draw symbol, fn(coord, coord, 
 3368             coord, coord, num, colr) 
 3369          @param scalable : not used 
 3370      """ 
 3371   
 3372      _fl_add_symbol = cfuncproto( 
 3373              load_so_libforms(), "fl_add_symbol",\ 
 3374              cty.c_int, [STRING, FL_DRAWPTR, cty.c_int],\ 
 3375              """int fl_add_symbol(const char * name, FL_DRAWPTR drawit, 
 3376                 int scalable) 
 3377              """) 
 3378      s_name = convert_to_string(name) 
 3379      iscalable = convert_to_int(scalable) 
 3380      c_DrawPtr = FL_DRAWPTR(py_DrawPtr) 
 3381      keep_cfunc_refs(c_DrawPtr, py_DrawPtr) 
 3382      keep_elem_refs(name, s_name, scalable, iscalable) 
 3383      retval = _fl_add_symbol(s_name, c_DrawPtr, iscalable) 
 3384      return retval 
 3385   
 3386   
 3387 -def fl_draw_symbol(label, x, y, w, h, colr): 
 3388      """ fl_draw_symbol(label, x, y, w, h, colr) -> num. 
 3389      """ 
 3390   
 3391      _fl_draw_symbol = cfuncproto( 
 3392              load_so_libforms(), "fl_draw_symbol",\ 
 3393              cty.c_int, [STRING, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 3394              FL_COLOR],\ 
 3395              """int fl_draw_symbol(const char * label, FL_Coord x, FL_Coord y, 
 3396                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 3397              """) 
 3398      slabel = convert_to_string(label) 
 3399      ix = convert_to_FL_Coord(x) 
 3400      iy = convert_to_FL_Coord(y) 
 3401      iw = convert_to_FL_Coord(w) 
 3402      ih = convert_to_FL_Coord(h) 
 3403      ulcolr = convert_to_FL_COLOR(colr) 
 3404      keep_elem_refs(label, slabel, x, ix, y, iy, w, iw, h, ih, colr, 
 3405                     ulcolr) 
 3406      retval = _fl_draw_symbol(slabel, ix, iy, iw, ih, ulcolr) 
 3407      return retval 
 3408   
 3409   
 3410 -def fl_mapcolor(colr, r, g, b): 
 3411      """ fl_mapcolor(colr, r, g, b) -> num. 
 3412      """ 
 3413   
 3414      _fl_mapcolor = cfuncproto( 
 3415              load_so_libforms(), "fl_mapcolor",\ 
 3416              cty.c_ulong, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 
 3417              """long unsigned int fl_mapcolor(FL_COLOR col, int r, int g, int b) 
 3418              """) 
 3419      ulcolr = convert_to_FL_COLOR(colr) 
 3420      ir = convert_to_int(r) 
 3421      ig = convert_to_int(g) 
 3422      ib = convert_to_int(b) 
 3423      keep_elem_refs(colr, ulcolr, r, ir, g, ig, b, ib) 
 3424      retval = _fl_mapcolor(ulcolr, ir, ig, ib) 
 3425      return retval 
 3426   
 3427   
 3428 -def fl_mapcolorname(colr, name): 
 3429      """ fl_mapcolorname(colr, name) -> num. 
 3430      """ 
 3431   
 3432      _fl_mapcolorname = cfuncproto( 
 3433              load_so_libforms(), "fl_mapcolorname",\ 
 3434              cty.c_long, [FL_COLOR, STRING],\ 
 3435              """long int fl_mapcolorname(FL_COLOR col, const char * name) 
 3436              """) 
 3437      ulcolr = convert_to_FL_COLOR(colr) 
 3438      sname = convert_to_string(name) 
 3439      keep_elem_refs(colr, ulcolr, name, sname) 
 3440      retval = _fl_mapcolorname(ulcolr, sname) 
 3441      return retval 
 3442   
 3443   
 3444  fl_mapcolor_name = fl_mapcolorname 
 3445   
 3446   
 3447 -def fl_free_colors(c, n): 
 3448      """ fl_free_colors(c, n) 
 3449      """ 
 3450   
 3451      _fl_free_colors = cfuncproto( 
 3452              load_so_libforms(), "fl_free_colors",\ 
 3453              None, [cty.POINTER(FL_COLOR), cty.c_int],\ 
 3454              """void fl_free_colors(FL_COLOR * c, int n) 
 3455              """) 
 3456      inum = convert_to_int(n) 
 3457      keep_elem_refs(c, n, inum) 
 3458      _fl_free_colors(c, inum) 
 3459   
 3460   
 3461 -def fl_free_pixels(pix, n): 
 3462      """ fl_free_pixels(pix, n) 
 3463      """ 
 3464   
 3465      _fl_free_pixels = cfuncproto( 
 3466              load_so_libforms(), "fl_free_pixels",\ 
 3467              None, [cty.POINTER(cty.c_ulong), cty.c_int],\ 
 3468              """void fl_free_pixels(long unsigned int * pix, int n) 
 3469              """) 
 3470      inum = convert_to_int(n) 
 3471      keep_elem_refs(pix, n, inum) 
 3472      _fl_free_pixels(pix, inum) 
 3473   
 3474   
 3475 -def fl_set_color_leak(y): 
 3476      """ fl_set_color_leak(y) 
 3477      """ 
 3478   
 3479      _fl_set_color_leak = cfuncproto( 
 3480              load_so_libforms(), "fl_set_color_leak",\ 
 3481              None, [cty.c_int],\ 
 3482              """void fl_set_color_leak(int y) 
 3483              """) 
 3484      iy = convert_to_int(y) 
 3485      keep_elem_refs(y, iy) 
 3486      _fl_set_color_leak(iy) 
 3487   
 3488   
 3489  #def fl_getmcolor(colr, r, g, b)       *API change* 
 3490 -def fl_getmcolor(colr): 
 3491      """ fl_getmcolor(colr) -> num., r, g,b 
 3492      """ 
 3493   
 3494      _fl_getmcolor = cfuncproto( 
 3495              load_so_libforms(), "fl_getmcolor",\ 
 3496              cty.c_ulong, [FL_COLOR, cty.POINTER(cty.c_int),\ 
 3497              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 
 3498              """long unsigned int fl_getmcolor(FL_COLOR i, int * r, int * g, 
 3499                 int * b) 
 3500              """) 
 3501      check_admitted_listvalues(colr, COLOR_list) 
 3502      ulcolr = convert_to_FL_COLOR(colr) 
 3503      r, pr = make_int_and_pointer() 
 3504      g, pg = make_int_and_pointer() 
 3505      b, pb = make_int_and_pointer() 
 3506      keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 
 3507      retval = _fl_getmcolor(ulcolr, pr, pg, pb) 
 3508      return retval, r, g,b 
 3509   
 3510   
 3511 -def fl_get_pixel(colr): 
 3512      """ fl_get_pixel(colr) -> pixel num. 
 3513      """ 
 3514   
 3515      _fl_get_pixel = cfuncproto( 
 3516              load_so_libforms(), "fl_get_pixel",\ 
 3517              cty.c_ulong, [FL_COLOR],\ 
 3518              """long unsigned int fl_get_pixel(FL_COLOR col) 
 3519              """) 
 3520      check_admitted_listvalues(colr, COLOR_list) 
 3521      ulcolr = convert_to_FL_COLOR(colr) 
 3522      keep_elem_refs(colr, ulcolr) 
 3523      retval = _fl_get_pixel(ulcolr) 
 3524      return retval 
 3525   
 3526   
 3527  fl_get_flcolor = fl_get_pixel 
 3528   
 3529   
 3530  #def fl_get_icm_color(colr, r, g, b)       *API change* 
 3531 -def fl_get_icm_color(colr): 
 3532      """ fl_get_icm_color(colr) -> r, g,b 
 3533      """ 
 3534   
 3535      _fl_get_icm_color = cfuncproto( 
 3536              load_so_libforms(), "fl_get_icm_color",\ 
 3537              None, [FL_COLOR, cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
 3538              cty.POINTER(cty.c_int)],\ 
 3539              """void fl_get_icm_color(FL_COLOR col, int * r, int * g, int * b) 
 3540              """) 
 3541      check_admitted_listvalues(colr, COLOR_list) 
 3542      ulcolr = convert_to_FL_COLOR(colr) 
 3543      r, pr = make_int_and_pointer() 
 3544      g, pg = make_int_and_pointer() 
 3545      b, pb = make_int_and_pointer() 
 3546      keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 
 3547      _fl_get_icm_color(ulcolr, pr, pg, pb) 
 3548      return r, g,b 
 3549   
 3550   
 3551 -def fl_set_icm_color(colr, r, g, b): 
 3552      """ fl_set_icm_color(colr, r, g, b) 
 3553      """ 
 3554   
 3555      _fl_set_icm_color = cfuncproto( 
 3556              load_so_libforms(), "fl_set_icm_color",\ 
 3557              None, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 
 3558              """void fl_set_icm_color(FL_COLOR col, int r, int g, int b) 
 3559              """) 
 3560      ulcolr = convert_to_FL_COLOR(colr) 
 3561      ir = convert_to_int(r) 
 3562      ig = convert_to_int(g) 
 3563      ib = convert_to_int(b) 
 3564      keep_elem_refs(colr, ulcolr, r, g, b, ir, ig, ib) 
 3565      _fl_set_icm_color(ulcolr, ir, ig, ib) 
 3566   
 3567   
 3568 -def fl_color(colr): 
 3569      """ fl_color(colr) 
 3570      """ 
 3571   
 3572      _fl_color = cfuncproto( 
 3573              load_so_libforms(), "fl_color",\ 
 3574              None, [FL_COLOR],\ 
 3575              """void fl_color(FL_COLOR col) 
 3576              """) 
 3577      check_admitted_listvalues(colr, COLOR_list) 
 3578      ulcolr = convert_to_FL_COLOR(colr) 
 3579      keep_elem_refs(colr, ulcolr) 
 3580      _fl_color(ulcolr) 
 3581   
 3582   
 3583 -def fl_bk_color(colr): 
 3584      """ fl_bk_color(colr) 
 3585      """ 
 3586   
 3587      _fl_bk_color = cfuncproto( 
 3588              load_so_libforms(), "fl_bk_color",\ 
 3589              None, [FL_COLOR],\ 
 3590              """void fl_bk_color(FL_COLOR col) 
 3591              """) 
 3592      check_admitted_listvalues(colr, COLOR_list) 
 3593      ulcolr = convert_to_FL_COLOR(colr) 
 3594      keep_elem_refs(colr, ulcolr) 
 3595      _fl_bk_color(ulcolr) 
 3596   
 3597   
 3598 -def fl_textcolor(colr): 
 3599      """ fl_textcolor(colr) 
 3600      """ 
 3601   
 3602      _fl_textcolor = cfuncproto( 
 3603              load_so_libforms(), "fl_textcolor",\ 
 3604              None, [FL_COLOR],\ 
 3605              """void fl_textcolor(FL_COLOR col) 
 3606              """) 
 3607      check_admitted_listvalues(colr, COLOR_list) 
 3608      ulcolr = convert_to_FL_COLOR(colr) 
 3609      keep_elem_refs(colr, ulcolr) 
 3610      _fl_textcolor(ulcolr) 
 3611   
 3612   
 3613 -def fl_bk_textcolor(colr): 
 3614      """ fl_bk_textcolor(colr) 
 3615      """ 
 3616   
 3617      _fl_bk_textcolor = cfuncproto( 
 3618              load_so_libforms(), "fl_bk_textcolor",\ 
 3619              None, [FL_COLOR],\ 
 3620              """void fl_bk_textcolor(FL_COLOR col) 
 3621              """) 
 3622      check_admitted_listvalues(colr, COLOR_list) 
 3623      ulcolr = convert_to_FL_COLOR(colr) 
 3624      keep_elem_refs(colr, ulcolr) 
 3625      _fl_bk_textcolor(ulcolr) 
 3626   
 3627   
 3628 -def fl_set_gamma(r, g, b): 
 3629      """ 
 3630          fl_set_gamma(r, g, b) 
 3631   
 3632          @param r : value for red 
 3633          @param g : value for green 
 3634          @param b : value for blue 
 3635      """ 
 3636   
 3637      _fl_set_gamma = cfuncproto( 
 3638              load_so_libforms(), "fl_set_gamma",\ 
 3639              None, [cty.c_double, cty.c_double, cty.c_double],\ 
 3640              """void fl_set_gamma(double r, double g, double b) 
 3641              """) 
 3642      fr = convert_to_double(r) 
 3643      fg = convert_to_double(g) 
 3644      fb = convert_to_double(b) 
 3645      keep_elem_refs(r, fr, g, fg, b, fb) 
 3646      _fl_set_gamma(fr, fg, fb) 
 3647   
 3648   
 3649 -def fl_show_errors(y): 
 3650      """ fl_show_errors(y) 
 3651      """ 
 3652   
 3653      _fl_show_errors = cfuncproto( 
 3654              load_so_libforms(), "fl_show_errors",\ 
 3655              None, [cty.c_int],\ 
 3656              """void fl_show_errors(int y) 
 3657              """) 
 3658      iy = convert_to_int(y) 
 3659      keep_elem_refs(y, iy) 
 3660      _fl_show_errors(iy) 
 3661   
 3662   
 3663  # Some macros 
 3664   
 3665 -def FL_max(a, b): 
 3666      if (a > b): 
 3667          return a 
 3668      else: 
 3669          return b 
 3670   
 3671 -def FL_min(a, b): 
 3672      if (a < b): 
 3673          return a 
 3674      else: 
 3675          return b 
 3676   
 3677 -def FL_abs(a): 
 3678      if (a > 0): 
 3679          return a 
 3680      else: 
 3681          return (-a) 
 3682   
 3683 -def FL_nint(a): 
 3684      if int(a) > 0: 
 3685          return (a + 0.5) 
 3686      else: 
 3687          return (a - 0.5) 
 3688   
 3689 -def FL_clamp(a, amin, amax): 
 3690      if (a < amin): 
 3691          return amin 
 3692      elif (a > amax): 
 3693          return amax 
 3694      else: 
 3695          return a 
 3696   
 3697 -def FL_crnd(a): 
 3698      if FL_Coord(a) > 0: 
 3699          return (a + 0.5) 
 3700      else: 
 3701          return (a - 0.5) 
 3702   
 3703   
 3704  # utilities for new objects 
 3705   
 3706 -def fl_add_object(pForm, pObject): 
 3707      """ 
 3708          fl_add_object(pForm, pObject) 
 3709   
 3710          @param pForm : pointer to form 
 3711          @param pObject : pointer to object 
 3712      """ 
 3713   
 3714      _fl_add_object = cfuncproto( 
 3715              load_so_libforms(), "fl_add_object",\ 
 3716              None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)],\ 
 3717              """void fl_add_object(FL_FORM * form, FL_OBJECT * obj) 
 3718              """) 
 3719      keep_elem_refs(pForm, pObject) 
 3720      _fl_add_object(pForm, pObject) 
 3721   
 3722   
 3723 -def fl_addto_form(pForm): 
 3724      """ 
 3725          fl_addto_form(pForm) -> pForm 
 3726   
 3727          Reopens a form for input. 
 3728   
 3729          @param pForm : pointer to form 
 3730      """ 
 3731   
 3732      _fl_addto_form = cfuncproto( 
 3733              load_so_libforms(), "fl_addto_form", 
 3734              cty.POINTER(FL_FORM), [cty.POINTER(FL_FORM)],\ 
 3735              """FL_FORM * fl_addto_form(FL_FORM * form) 
 3736              """) 
 3737      keep_elem_refs(pForm) 
 3738      retval = _fl_addto_form(pForm) 
 3739      return retval 
 3740   
 3741   
 3742 -def fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr): 
 3743      """ 
 3744          fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr) -> pObject 
 3745      """ 
 3746   
 3747      _fl_make_object = cfuncproto( 
 3748              load_so_libforms(), "fl_make_object",\ 
 3749              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord,\ 
 3750              FL_Coord, FL_Coord, FL_Coord, STRING, FL_HANDLEPTR],\ 
 3751              """FL_OBJECT * fl_make_object(int objclass, int type, FL_Coord x, 
 3752                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label, 
 3753                 FL_HANDLEPTR handle) 
 3754              """) 
 3755      iobjclass = convert_to_int(objclass) 
 3756      iobjtype = convert_to_int(objtype) 
 3757      ix = convert_to_FL_Coord(x) 
 3758      iy = convert_to_FL_Coord(y) 
 3759      iw = convert_to_FL_Coord(w) 
 3760      ih = convert_to_FL_Coord(h) 
 3761      slabel = convert_to_string(label) 
 3762      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
 3763      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
 3764      keep_elem_refs(objclass, objtype, x, y, w, h, label, iobjclass, 
 3765                     iobjtype, ix, iy, iw, ih, slabel) 
 3766      retval = _fl_make_object(iobjclass, iobjtype, ix, iy, iw, 
 3767                               ih, slabel, c_HandlePtr) 
 3768      return retval 
 3769   
 3770   
 3771 -def fl_add_child(pObject1, pObject2): 
 3772      """ 
 3773          fl_add_child(pObject1, pObject2) 
 3774   
 3775          @param pObject1 : pointer to father object 
 3776          @param pObject2 : pointer to child object 
 3777      """ 
 3778   
 3779      _fl_add_child = cfuncproto( 
 3780              load_so_libforms(), "fl_add_child",\ 
 3781              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)],\ 
 3782              """void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2) 
 3783              """) 
 3784      keep_elem_refs(pObject1, pObject2) 
 3785      _fl_add_child(pObject1, pObject2) 
 3786   
 3787   
 3788 -def fl_set_coordunit(u): 
 3789      """ 
 3790          fl_set_coordunit(u) 
 3791   
 3792          @param u :? 
 3793      """ 
 3794   
 3795      _fl_set_coordunit = cfuncproto( 
 3796              load_so_libforms(), "fl_set_coordunit",\ 
 3797              None, [cty.c_int],\ 
 3798              """void fl_set_coordunit(int u) 
 3799              """) 
 3800      iu = convert_to_int(u) 
 3801      keep_elem_refs(u, iu) 
 3802      _fl_set_coordunit(iu) 
 3803   
 3804   
 3805 -def fl_set_border_width(bw): 
 3806      """ 
 3807          fl_set_border_width(bw) 
 3808   
 3809          Sets the width of the border. 
 3810   
 3811          @param bw : width of border 
 3812      """ 
 3813   
 3814      _fl_set_border_width = cfuncproto( 
 3815              load_so_libforms(), "fl_set_border_width",\ 
 3816              None, [cty.c_int],\ 
 3817              """void fl_set_border_width(int bw) 
 3818              """) 
 3819      ibw = convert_to_int(bw) 
 3820      keep_elem_refs(bw, ibw) 
 3821      _fl_set_border_width(ibw) 
 3822   
 3823   
 3824 -def fl_set_scrollbar_type(sbtype): 
 3825      """ 
 3826          fl_set_scrollbar_type(sbtype) 
 3827   
 3828          @param sbtype : type of scrollbar 
 3829      """ 
 3830   
 3831      _fl_set_scrollbar_type = cfuncproto( 
 3832              load_so_libforms(), "fl_set_scrollbar_type",\ 
 3833              None, [cty.c_int],\ 
 3834              """void fl_set_scrollbar_type(int t) 
 3835              """) 
 3836      check_admitted_listvalues(sbtype, SCROLLTYPE_list) 
 3837      isbtype = convert_to_int(sbtype) 
 3838      keep_elem_refs(sbtype, isbtype) 
 3839      _fl_set_scrollbar_type(isbtype) 
 3840   
 3841   
 3842 -def fl_set_thinscrollbar(t): 
 3843      if t: 
 3844          t_type = FL_THIN_SCROLLBAR 
 3845      else: 
 3846          t_type = FL_NORMAL_SCROLLBAR 
 3847      fl_set_scrollbar_type(t_type) 
 3848   
 3849   
 3850 -def fl_flip_yorigin(): 
 3851      """ fl_flip_yorigin() 
 3852      """ 
 3853   
 3854      _fl_flip_yorigin = cfuncproto( 
 3855              load_so_libforms(), "fl_flip_yorigin",\ 
 3856              None, [],\ 
 3857              """void fl_flip_yorigin() 
 3858              """) 
 3859      _fl_flip_yorigin() 
 3860   
 3861   
 3862 -def fl_get_coordunit(): 
 3863      """ fl_get_coordunit() -> coord_unit num. 
 3864      """ 
 3865   
 3866      _fl_get_coordunit = cfuncproto( 
 3867              load_so_libforms(), "fl_get_coordunit",\ 
 3868              cty.c_int, [],\ 
 3869              """int fl_get_coordunit() 
 3870              """) 
 3871      retval = _fl_get_coordunit() 
 3872      return retval 
 3873   
 3874   
 3875 -def fl_get_border_width(): 
 3876      """ fl_get_border_width() -> width num. 
 3877      """ 
 3878   
 3879      _fl_get_border_width = cfuncproto( 
 3880              load_so_libforms(), "fl_get_border_width",\ 
 3881              cty.c_int, [],\ 
 3882              """int fl_get_border_width() 
 3883              """) 
 3884      retval = _fl_get_border_width() 
 3885      return retval 
 3886   
 3887   
 3888  # misc. routines 
 3889   
 3890 -def fl_ringbell(percent): 
 3891      """ 
 3892          fl_ringbell(percent) 
 3893   
 3894          Sounds the keyboard ringbell (if capable). 
 3895   
 3896          @param percent : volume value for the bell, min -100 (off), max  100, 
 3897             0 is default 
 3898      """ 
 3899   
 3900      _fl_ringbell = cfuncproto( 
 3901              load_so_libforms(), "fl_ringbell",\ 
 3902              None, [cty.c_int],\ 
 3903              """void fl_ringbell(int percent) 
 3904              """) 
 3905      ipercent = convert_to_int(percent) 
 3906      keep_elem_refs(percent, ipercent) 
 3907      _fl_ringbell(ipercent) 
 3908   
 3909   
 3910  #def fl_gettime(sec, usec)       *API change* 
 3911 -def fl_gettime(): 
 3912      """ 
 3913          fl_gettime() -> sec, usec 
 3914   
 3915          Returns the current time, expressed in seconds and microseconds 
 3916          since 00:00 GMT January, 1970. It is most useful for computing 
 3917          time differences 
 3918      """ 
 3919   
 3920      _fl_gettime = cfuncproto( 
 3921              load_so_libforms(), "fl_gettime",\ 
 3922              None, [cty.POINTER(cty.c_long), cty.POINTER(cty.c_long)],\ 
 3923              """void fl_gettime(long int * sec, long int * usec) 
 3924              """) 
 3925      sec, psec = make_long_and_pointer() 
 3926      usec, pusec = make_long_and_pointer() 
 3927      keep_elem_refs(sec, usec, psec, pusec) 
 3928      _fl_gettime(psec, pusec) 
 3929      return sec, usec 
 3930   
 3931   
 3932 -def fl_now(): 
 3933      """ 
 3934          fl_now() -> string 
 3935   
 3936          Returns a string form of the current date and time. The format of 
 3937          the string is of the form "Wed Jun 30 21:49:08 1993" 
 3938      """ 
 3939   
 3940      _fl_now = cfuncproto( 
 3941              load_so_libforms(), "fl_now",\ 
 3942              STRING, [],\ 
 3943              """const char * fl_now() 
 3944              """) 
 3945      retval = _fl_now() 
 3946      return retval 
 3947   
 3948   
 3949 -def fl_whoami(): 
 3950      """ 
 3951          fl_whoami() -> string 
 3952   
 3953          Returns the user name who is running the application. 
 3954      """ 
 3955   
 3956      _fl_whoami = cfuncproto( 
 3957              load_so_libforms(), "fl_whoami",\ 
 3958              STRING, [],\ 
 3959              """const char * fl_whoami() 
 3960              """) 
 3961      retval = _fl_whoami() 
 3962      return retval 
 3963   
 3964   
 3965 -def fl_mouse_button(): 
 3966      """ fl_mouse_button() -> num. 
 3967      """ 
 3968   
 3969      _fl_mouse_button = cfuncproto( 
 3970              load_so_libforms(), "fl_mouse_button",\ 
 3971              cty.c_long, [],\ 
 3972              """long int fl_mouse_button() 
 3973              """) 
 3974      retval = _fl_mouse_button() 
 3975      return retval 
 3976   
 3977  fl_mousebutton = fl_mouse_button 
 3978   
 3979   
 3980   
 3981 -def fl_strdup(strng): 
 3982      """ fl_strdup(strng) -> string 
 3983      """ 
 3984   
 3985      _fl_strdup = cfuncproto( 
 3986              load_so_libforms(), "fl_strdup",\ 
 3987              STRING, [STRING],\ 
 3988              """char * fl_strdup(const char * s) 
 3989              """) 
 3990      sstrng = convert_to_string(strng) 
 3991      keep_elem_refs(strng, sstrng) 
 3992      retval = _fl_strdup(sstrng) 
 3993      return retval 
 3994   
 3995   
 3996 -def fl_set_err_logfp(pFile): 
 3997      """ fl_set_err_logfp(pFile) 
 3998      """ 
 3999   
 4000      _fl_set_err_logfp = cfuncproto( 
 4001              load_so_libforms(), "fl_set_err_logfp",\ 
 4002              None, [cty.POINTER(FILE)],\ 
 4003              """void fl_set_err_logfp(FILE * fp) 
 4004              """) 
 4005      keep_elem_refs(pFile) 
 4006      _fl_set_err_logfp(pFile) 
 4007   
 4008  # This function was called 'fl_set_error_logfp/' in XForms 0.89. 
 4009  fl_set_error_logfp = fl_set_err_logfp 
 4010   
 4011   
 4012   
 4013 -def fl_set_error_handler(py_ErrorFunc): 
 4014      """ 
 4015          fl_set_error_handler(py_ErrorFunc) 
 4016      """ 
 4017   
 4018      _fl_set_error_handler = cfuncproto( 
 4019              load_so_libforms(), "fl_set_error_handler",\ 
 4020              None, [FL_ERROR_FUNC],\ 
 4021              """void fl_set_error_handler(FL_ERROR_FUNC user_func) 
 4022              """) 
 4023      c_ErrorFunc = FL_ERROR_FUNC(py_ErrorFunc) 
 4024      keep_cfunc_refs(c_ErrorFunc, py_ErrorFunc) 
 4025      retval = _fl_set_error_handler(c_ErrorFunc) 
 4026      return retval 
 4027   
 4028   
 4029 -def fl_get_cmdline_args(p1): 
 4030      """ fl_get_cmdline_args(p1) -> string 
 4031      """ 
 4032   
 4033      _fl_get_cmdline_args = cfuncproto( 
 4034              load_so_libforms(), "fl_get_cmdline_args",\ 
 4035              cty.POINTER(STRING), [cty.POINTER(cty.c_int)],\ 
 4036              """)char * * fl_get_cmdline_args(int * p1) 
 4037              """) 
 4038      keep_elem_refs(p1) 
 4039      retval = _fl_get_cmdline_args(p1) 
 4040      return retval 
 4041   
 4042   
 4043  # these give more flexibility for future changes. Also application 
 4044  # can re-assign these pointers to whatever function it wants, e.g., 
 4045  # to a shared memory pool allocator. 
 4046   
 4047  #fl_free = (cty.CFUNCTYPE(None, cty.c_void_p)).in_dll(load_so_libforms(), 'fl_free') 
 4048 -def fl_free(p1): 
 4049      """ fl_free(p1) 
 4050      """ 
 4051   
 4052      _fl_free = cfuncproto( 
 4053              load_so_libforms(), "fl_free",\ 
 4054              None, [cty.c_void_p], 
 4055              """void ( * fl_free )( void *) 
 4056              """) 
 4057      keep_elem_refs(p1) 
 4058      _fl_free(p1) 
 4059   
 4060   
 4061  # cfunction for _fl_malloc 
 4062  cfunc_none_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t) 
 4063   
 4064  # low-level function maybe unused in python 
 4065  ##fl_malloc = (cty.CFUNCTYPE(cty.c_void_p, size_t)).in_dll(load_so_libforms(), 
 4066  #             'fl_malloc') 
 4067  #def fl_malloc(size): 
 4068  #    """ fl_malloc(size) -> pointer 
 4069  #    """# 
 4070  #   _fl_malloc = cfuncproto( 
 4071  #           load_so_libforms(), "fl_malloc",\ 
 4072  #           cty.c_void_p, [size_t], 
 4073  #           """void * ( * fl_malloc )( size_t) 
 4074  #           """) 
 4075  #    uisize = convert_to_uint(size) 
 4076  #    keep_elem_refs(size, uisize) 
 4077  #    retval = _fl_malloc(uisize) 
 4078  #    return retval 
 4079   
 4080   
 4081  # cfunction for _fl_calloc 
 4082  cfunc_none_sizet_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t, size_t) 
 4083   
 4084  # low-level function maybe unused in python 
 4085  ##fl_calloc = (cty.CFUNCTYPE(cty.c_void_p, size_t, size_t)).in_dll(\ 
 4086  #             load_so_libforms(), 'fl_calloc') 
 4087  #def fl_calloc(size): 
 4088  #    """ fl_calloc(size) -> pointer 
 4089  #    """# 
 4090  #   _fl_calloc = cfuncproto( 
 4091  #        load_so_libforms(), "fl_malloc",\ 
 4092  #        cty.c_void_p, [size_t, size_t], 
 4093  #        """void * ( * fl_calloc )( size_t) 
 4094  #        """) 
 4095  #    uisize = convert_to_uint(size) 
 4096  #    keep_elem_refs(size, uisize) 
 4097  #    retval = _fl_calloc(uisize) 
 4098  #    return retval 
 4099   
 4100   
 4101  # cfunction for _fl_realloc 
 4102  cfunc_voidp_voidp_sizet = cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t) 
 4103   
 4104  # low-level function maybe unused in python 
 4105  ##fl_realloc = (cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t)).in_dll(\ 
 4106  #               load_so_libforms(), 'fl_realloc') 
 4107  #def fl_realloc(py_p1, size): 
 4108  #    """ fl_realloc(py_p1, size) -> pointer 
 4109  #    """# 
 4110  #    _fl_realloc = cfuncproto( 
 4111  #        load_so_libforms(), "fl_realloc",\ 
 4112  #        cty.c_void_p, [cty.c_void_p, size_t], 
 4113  #        """void * ( * fl_realloc )( void* 
 4114  #        """) 
 4115  #    uisize = convert_to_uint(size) 
 4116  #    c_p1 = cfunc_voidp_voidp_sizet(py_p1) 
 4117  #    keep_cfunc_refs(c_p1) 
 4118  #    keep_elem_refs(size, uisize) 
 4119  #    retval = _fl_realloc(c_p1, uisize) 
 4120  #    return retval 
 4121   
 4122   
 4123 -def fl_msleep(msec): 
 4124      """ 
 4125          fl_msleep(msec) -> num. 
 4126   
 4127          Waits for a number of milliseconds (with the best resolution 
 4128          possible on your system) 
 4129   
 4130          @param msec : milliseconds to sleep 
 4131      """ 
 4132   
 4133      _fl_msleep = cfuncproto( 
 4134              load_so_libforms(), "fl_msleep",\ 
 4135              cty.c_int, [cty.c_ulong],\ 
 4136              """int fl_msleep(long unsigned int msec) 
 4137              """) 
 4138      ulmsec = convert_to_ulong(msec) 
 4139      keep_elem_refs(msec, ulmsec) 
 4140      retval = _fl_msleep(ulmsec) 
 4141      return retval 
 4142   
 4143   
 4144 -def fl_is_same_object(pObject1, pObject2): 
 4145      """ 
 4146          fl_is_same_object(pObject1, pObject2) -> num. 
 4147   
 4148          Does a comparison between two objects. 
 4149      """ 
 4150   
 4151      _fl_is_same_object = cfuncproto( 
 4152              load_so_libforms(), "fl_is_same_object", \ 
 4153              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)], \ 
 4154              """int fl_is_same_object(FL_OBJECT * obj1, FL_OBJECT * obj2) 
 4155              """) 
 4156      keep_elem_refs(pObject1, pObject2) 
 4157      retval = _fl_is_same_object(pObject1, pObject2) 
 4158      return retval 
 4159   
 4160   
 4161   
 4162  ########################### 
 4163  # forms.h (XBasic.h) 
 4164  # X Window dependent stuff 
 4165  ########################### 
 4166   
 4167 -def FL_is_gray(v): 
 4168      if (v == GrayScale) or (v == StaticGray): 
 4169          return True 
 4170      else: 
 4171          return False 
 4172   
 4173   
 4174 -def FL_is_rgb(v): 
 4175      if (v == TrueColor) or (v == DirectColor): 
 4176          return True 
 4177      else: 
 4178          return False 
 4179   
 4180   
 4181  # Current version only runs in single visual mode 
 4182 -def fl_get_vclass(): 
 4183      return fl_vmode 
 4184   
 4185   
 4186 -def fl_get_form_vclass(a): 
 4187      return fl_vmode 
 4188   
 4189   
 4190 -def fl_get_gc(): 
 4191      return fl_state[fl_vmode].gc[0] 
 4192   
 4193   
 4194 -def fl_mode_capable(mode, warn): 
 4195      """ 
 4196          fl_mode_capable(mode, warn) -> mode num. 
 4197   
 4198          Determines the visual classes the system is capable of. It returns 
 4199          1 if the system is capable of displaying in this visual class and 
 4200          0 otherwise. 
 4201   
 4202          @param mode : visual mode (i.e. xfc.FL_GrayScale, xfc.FL_StaticGray, 
 4203             xfc.FL_PseudoColor, xfc.FL_StaticColor, xfc.FL_DirectColor and 
 4204             xfc.FL_TrueColor) 
 4205          @param warn : warning (0|1), if set a warning is printed out in case 
 4206             the capability asked for isn't available 
 4207      """ 
 4208   
 4209      _fl_mode_capable = cfuncproto( 
 4210              load_so_libforms(), "fl_mode_capable",\ 
 4211              cty.c_int, [cty.c_int, cty.c_int],\ 
 4212              """int fl_mode_capable(int mode, int warn) 
 4213              """) 
 4214      imode = convert_to_int(mode) 
 4215      iwarn = convert_to_int(warn) 
 4216      keep_elem_refs(mode, warn, imode, iwarn) 
 4217      retval = _fl_mode_capable(imode, iwarn) 
 4218      return retval 
 4219   
 4220   
 4221 -def fl_default_win(): 
 4222      return fl_state[fl_vmode].trailblazer 
 4223   
 4224   
 4225 -def fl_default_window(): 
 4226      return fl_state[fl_vmode].trailblazer 
 4227   
 4228   
 4229  # Some basic drawing routines 
 4230   
 4231  # Rectangles 
 4232   
 4233 -def fl_rectangle(fill, x, y, w, h, colr): 
 4234      """ fl_rectangle(fill, x, y, w, h, colr) 
 4235      """ 
 4236   
 4237      _fl_rectangle = cfuncproto( 
 4238              load_so_libforms(), "fl_rectangle",\ 
 4239              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4240              FL_COLOR],\ 
 4241              """void fl_rectangle(int fill, FL_Coord x, FL_Coord y, 
 4242                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 4243              """) 
 4244      check_admitted_listvalues(colr, COLOR_list) 
 4245      ifill = convert_to_int(fill) 
 4246      ix = convert_to_FL_Coord(x) 
 4247      iy = convert_to_FL_Coord(y) 
 4248      iw = convert_to_FL_Coord(w) 
 4249      ih = convert_to_FL_Coord(h) 
 4250      ulcolr = convert_to_FL_COLOR(colr) 
 4251      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4252                     ulcolr) 
 4253      _fl_rectangle(ifill, ix, iy, iw, ih, ulcolr) 
 4254   
 4255   
 4256 -def fl_rectbound(x, y, w, h, colr): 
 4257      """ fl_rectbound(x, y, w, h, colr) 
 4258      """ 
 4259   
 4260      _fl_rectbound = cfuncproto( 
 4261              load_so_libforms(), "fl_rectbound",\ 
 4262              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4263              """void fl_rectbound(FL_Coord x, FL_Coord y, FL_Coord w, 
 4264                 FL_Coord h, FL_COLOR col) 
 4265              """) 
 4266      check_admitted_listvalues(colr, COLOR_list) 
 4267      ix = convert_to_FL_Coord(x) 
 4268      iy = convert_to_FL_Coord(y) 
 4269      iw = convert_to_FL_Coord(w) 
 4270      ih = convert_to_FL_Coord(h) 
 4271      ulcolr = convert_to_FL_COLOR(colr) 
 4272      keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 
 4273      _fl_rectbound(ix, iy, iw, ih, ulcolr) 
 4274   
 4275   
 4276 -def fl_rectf(x, y, w, h, colr): 
 4277      fl_rectangle(1, x, y, w, h, colr) 
 4278   
 4279   
 4280 -def fl_rect(x, y, w, h, colr): 
 4281      fl_rectangle(0, x, y, w, h, colr) 
 4282   
 4283   
 4284  # Rectangle with rounded-corners 
 4285   
 4286 -def fl_roundrectangle(fill, x, y, w, h, colr): 
 4287      """ fl_roundrectangle(fill, x, y, w, h, colr) 
 4288      """ 
 4289   
 4290      _fl_roundrectangle = cfuncproto( 
 4291              load_so_libforms(), "fl_roundrectangle",\ 
 4292              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4293              FL_COLOR],\ 
 4294              """void fl_roundrectangle(int fill, FL_Coord x, FL_Coord y, 
 4295                 FL_Coord w, FL_Coord h, FL_COLOR col) 
 4296              """) 
 4297      check_admitted_listvalues(colr, COLOR_list) 
 4298      ifill = convert_to_int(fill) 
 4299      ix = convert_to_FL_Coord(x) 
 4300      iy = convert_to_FL_Coord(y) 
 4301      iw = convert_to_FL_Coord(w) 
 4302      ih = convert_to_FL_Coord(h) 
 4303      ulcolr = convert_to_FL_COLOR(colr) 
 4304      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4305                     ulcolr) 
 4306      _fl_roundrectangle(ifill, ix, iy, iw, ih, ulcolr) 
 4307   
 4308   
 4309 -def fl_roundrectf(x, y, w, h, colr): 
 4310      fl_roundrectangle(1, x, y, w, h, colr) 
 4311   
 4312   
 4313 -def fl_roundrect(x, y, w, h, colr): 
 4314      fl_roundrectangle(0, x, y, w, h, colr) 
 4315   
 4316   
 4317  # General polygon and polylines 
 4318   
 4319 -def fl_polygon(fill, pPoint, n, colr): 
 4320      """ fl_polygon(fill, pPoint, n, colr) 
 4321      """ 
 4322   
 4323      _fl_polygon = cfuncproto( 
 4324              load_so_libforms(), "fl_polygon",\ 
 4325              None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4326              """void fl_polygon(int fill, FL_POINT * xp, int n, FL_COLOR col) 
 4327              """) 
 4328      check_admitted_listvalues(colr, COLOR_list) 
 4329      ifill = convert_to_int(fill) 
 4330      inum = convert_to_int(n) 
 4331      ulcolr = convert_to_FL_COLOR(colr) 
 4332      keep_elem_refs(fill, pPoint, n, colr, ifill, inum, ulcolr) 
 4333      _fl_polygon(ifill, pPoint, inum, ulcolr) 
 4334   
 4335   
 4336 -def fl_polyf(pPoint, n, colr): 
 4337      fl_polygon(1, pPoint, n, colr) 
 4338   
 4339   
 4340 -def fl_polyl(pPoint, n, colr): 
 4341      fl_polygon(0, pPoint, n, colr) 
 4342   
 4343 -def fl_polybound(pPoint, n, colr): 
 4344      fl_polygon(1, pPoint, n, colr) 
 4345      fl_polygon(0, pPoint, n, FL_BLACK) 
 4346   
 4347   
 4348 -def fl_lines(pPoint, n, colr): 
 4349      """ fl_lines(pPoint, n, colr) 
 4350      """ 
 4351   
 4352      _fl_lines = cfuncproto( 
 4353              load_so_libforms(), "fl_lines",\ 
 4354              None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4355              """void fl_lines(FL_POINT * xp, int n, FL_COLOR col) 
 4356              """) 
 4357      check_admitted_listvalues(colr, COLOR_list) 
 4358      inum = convert_to_int(n) 
 4359      ulcolr = convert_to_FL_COLOR(colr) 
 4360      keep_elem_refs(pPoint, n, colr, inum, ulcolr) 
 4361      _fl_lines(pPoint, inum, ulcolr) 
 4362   
 4363   
 4364 -def fl_line(xi, yi, xf, yf, colr): 
 4365      """ fl_line(xi, yi, xf, yf, colr) 
 4366      """ 
 4367   
 4368      _fl_line = cfuncproto( 
 4369              load_so_libforms(), "fl_line",\ 
 4370              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4371              """void fl_line(FL_Coord xi, FL_Coord yi, FL_Coord xf, 
 4372                 FL_Coord yf, FL_COLOR c) 
 4373              """) 
 4374      check_admitted_listvalues(colr, COLOR_list) 
 4375      ixi = convert_to_int(xi) 
 4376      iyi = convert_to_int(yi) 
 4377      ixf = convert_to_int(xf) 
 4378      iyf = convert_to_int(yf) 
 4379      ulcolr = convert_to_FL_COLOR(colr) 
 4380      keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, ulcolr) 
 4381      _fl_line(ixi, iyi, ixf, iyf, ulcolr) 
 4382   
 4383   
 4384 -def fl_point(x, y, colr): 
 4385      """ fl_point(x, y, colr) 
 4386      """ 
 4387   
 4388      _fl_point = cfuncproto( 
 4389              load_so_libforms(), "fl_point",\ 
 4390              None, [FL_Coord, FL_Coord, FL_COLOR],\ 
 4391              """void fl_point(FL_Coord x, FL_Coord y, FL_COLOR c) 
 4392              """) 
 4393      check_admitted_listvalues(colr, COLOR_list) 
 4394      ix = convert_to_FL_Coord(x) 
 4395      iy = convert_to_FL_Coord(y) 
 4396      ulcolr = convert_to_FL_COLOR(colr) 
 4397      keep_elem_refs(x, y, colr, ix, iy, ulcolr) 
 4398      _fl_point(ix, iy, ulcolr) 
 4399   
 4400   
 4401 -def fl_points(pPoint, np, colr): 
 4402      """ fl_points(pPoint, np, colr) 
 4403      """ 
 4404   
 4405      _fl_points = cfuncproto( 
 4406              load_so_libforms(), "fl_points",\ 
 4407              None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 
 4408              """void fl_points(FL_POINT * p, int np, FL_COLOR c) 
 4409              """) 
 4410      check_admitted_listvalues(colr, COLOR_list) 
 4411      inump = convert_to_int(np) 
 4412      ulcolr = convert_to_FL_COLOR(colr) 
 4413      keep_elem_refs(pPoint, np, colr, inump, ulcolr) 
 4414      _fl_points(pPoint, inump, ulcolr) 
 4415   
 4416   
 4417  fl_simple_line = fl_line 
 4418   
 4419   
 4420 -def fl_dashedlinestyle(dash, ndash): 
 4421      """ fl_dashedlinestyle(dash, ndash) 
 4422      """ 
 4423   
 4424      _fl_dashedlinestyle = cfuncproto( 
 4425              load_so_libforms(), "fl_dashedlinestyle",\ 
 4426              None, [STRING, cty.c_int],\ 
 4427              """void fl_dashedlinestyle(const char * dash, int ndash) 
 4428              """) 
 4429      sdash = convert_to_string(dash) 
 4430      indash = convert_to_int(ndash) 
 4431      keep_elem_refs(dash, ndash, sdash, indash) 
 4432      _fl_dashedlinestyle(sdash, indash) 
 4433   
 4434   
 4435 -def fl_update_display(block): 
 4436      """ fl_update_display(block) 
 4437      """ 
 4438   
 4439      _fl_update_display = cfuncproto( 
 4440              load_so_libforms(), "fl_update_display",\ 
 4441              None, [cty.c_int],\ 
 4442              """void fl_update_display(int block) 
 4443              """) 
 4444      iblock = convert_to_int(block) 
 4445      keep_elem_refs(block, iblock) 
 4446      _fl_update_display(iblock) 
 4447   
 4448   
 4449 -def fl_diagline(x, y, w, h, colr): 
 4450      fl_line(x, y, (x) + (w) - 1, (y) + (h) - 1, colr) 
 4451   
 4452   
 4453  # Line attributes 
 4454   
 4455 -def fl_linewidth(n): 
 4456      """ fl_linewidth(n) 
 4457      """ 
 4458   
 4459      _fl_linewidth = cfuncproto( 
 4460              load_so_libforms(), "fl_linewidth",\ 
 4461              None, [cty.c_int],\ 
 4462              """void fl_linewidth(int n) 
 4463              """) 
 4464      inum = convert_to_int(n) 
 4465      keep_elem_refs(n, inum) 
 4466      _fl_linewidth(inum) 
 4467   
 4468   
 4469 -def fl_linestyle(n): 
 4470      """ fl_linestyle(n) 
 4471      """ 
 4472   
 4473      _fl_linestyle = cfuncproto( 
 4474              load_so_libforms(), "fl_linestyle",\ 
 4475              None, [cty.c_int],\ 
 4476              """void fl_linestyle(int n) 
 4477              """) 
 4478      inum = convert_to_int(n) 
 4479      keep_elem_refs(n, inum) 
 4480      _fl_linestyle(inum) 
 4481   
 4482   
 4483 -def fl_drawmode(request): 
 4484      """ fl_drawmode(request) 
 4485      """ 
 4486   
 4487      _fl_drawmode = cfuncproto( 
 4488              load_so_libforms(), "fl_drawmode",\ 
 4489              None, [cty.c_int],\ 
 4490              """void fl_drawmode(int request) 
 4491              """) 
 4492      irequest = convert_to_int(request) 
 4493      keep_elem_refs(request, irequest) 
 4494      _fl_drawmode(irequest) 
 4495   
 4496   
 4497 -def fl_get_linewidth(): 
 4498      """ fl_get_linewidth() -> width num. 
 4499      """ 
 4500   
 4501      _fl_get_linewidth = cfuncproto( 
 4502              load_so_libforms(), "fl_get_linewidth",\ 
 4503              cty.c_int, [],\ 
 4504              """int fl_get_linewidth() 
 4505              """) 
 4506      retval = _fl_get_linewidth() 
 4507      return retval 
 4508   
 4509   
 4510 -def fl_get_linestyle(): 
 4511      """ fl_get_linestyle() -> style num. 
 4512      """ 
 4513   
 4514      _fl_get_linestyle = cfuncproto( 
 4515              load_so_libforms(), "fl_get_linestyle",\ 
 4516              cty.c_int, [],\ 
 4517              """int fl_get_linestyle() 
 4518              """) 
 4519      retval = _fl_get_linestyle() 
 4520      return retval 
 4521   
 4522   
 4523 -def fl_get_drawmode(): 
 4524      """ fl_get_drawmode() -> mode num. 
 4525      """ 
 4526   
 4527      _fl_get_drawmode = cfuncproto( 
 4528              load_so_libforms(), "fl_get_drawmode",\ 
 4529              cty.c_int, [],\ 
 4530              """int fl_get_drawmode() 
 4531              """) 
 4532      retval = _fl_get_drawmode() 
 4533      return retval 
 4534   
 4535   
 4536  fl_set_linewidth = fl_linewidth 
 4537  fl_set_linestyle = fl_linestyle 
 4538  fl_set_drawmode = fl_drawmode 
 4539   
 4540   
 4541  # Ellipses 
 4542   
 4543 -def fl_oval(fill, x, y, w, h, colr): 
 4544      """ fl_oval(fill, x, y, w, h, colr) 
 4545      """ 
 4546   
 4547      _fl_oval = cfuncproto( 
 4548              load_so_libforms(), "fl_oval",\ 
 4549              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4550              FL_COLOR],\ 
 4551              """void fl_oval(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4552                 FL_Coord h, FL_COLOR col) 
 4553              """) 
 4554      check_admitted_listvalues(colr, COLOR_list) 
 4555      ifill = convert_to_int(fill) 
 4556      ix = convert_to_FL_Coord(x) 
 4557      iy = convert_to_FL_Coord(y) 
 4558      iw = convert_to_FL_Coord(w) 
 4559      ih = convert_to_FL_Coord(h) 
 4560      ulcolr = convert_to_FL_COLOR(colr) 
 4561      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 
 4562                     ulcolr) 
 4563      _fl_oval(ifill, ix, iy, iw, ih, ulcolr) 
 4564   
 4565   
 4566 -def fl_ovalbound(x, y, w, h, colr): 
 4567      """ fl_ovalbound(x, y, w, h, colr) 
 4568      """ 
 4569   
 4570      _fl_ovalbound = cfuncproto( 
 4571              load_so_libforms(), "fl_ovalbound",\ 
 4572              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 
 4573              """void fl_ovalbound(FL_Coord x, FL_Coord y, FL_Coord w, 
 4574                 FL_Coord h, FL_COLOR col) 
 4575              """) 
 4576      check_admitted_listvalues(colr, COLOR_list) 
 4577      ix = convert_to_FL_Coord(x) 
 4578      iy = convert_to_FL_Coord(y) 
 4579      iw = convert_to_FL_Coord(w) 
 4580      ih = convert_to_FL_Coord(h) 
 4581      ulcolr = convert_to_FL_COLOR(colr) 
 4582      keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 
 4583      _fl_ovalbound(ix, iy, iw, ih, ulcolr) 
 4584   
 4585   
 4586 -def fl_ovalarc(fill, x, y, w, h, t0, dt, colr): 
 4587      """ fl_ovalarc(fill, x, y, w, h, t0, dt, colr) 
 4588      """ 
 4589   
 4590      _fl_ovalarc = cfuncproto( 
 4591              load_so_libforms(), "fl_ovalarc",\ 
 4592              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 
 4593              cty.c_int, cty.c_int, FL_COLOR],\ 
 4594              """void fl_ovalarc(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4595                 FL_Coord h, int t0, int dt, FL_COLOR col) 
 4596              """) 
 4597      check_admitted_listvalues(colr, COLOR_list) 
 4598      ifill = convert_to_int(fill) 
 4599      ix = convert_to_FL_Coord(x) 
 4600      iy = convert_to_FL_Coord(y) 
 4601      iw = convert_to_FL_Coord(w) 
 4602      ih = convert_to_FL_Coord(h) 
 4603      it0 = convert_to_int(t0) 
 4604      idt = convert_to_int(dt) 
 4605      ulcolr = convert_to_FL_COLOR(colr) 
 4606      keep_elem_refs(fill, x, y, w, h, t0, dt, colr, ifill, ix, iy, iw, 
 4607                     ih, it0, idt, ulcolr) 
 4608      _fl_ovalarc(ifill, ix, iy, iw, ih, it0, idt, ulcolr) 
 4609   
 4610   
 4611 -def fl_ovalf(x, y, w, h, colr): 
 4612      fl_oval(1, x, y, w, h, colr) 
 4613   
 4614   
 4615 -def fl_ovall(x, y, w, h, colr): 
 4616      fl_oval(0, x, y, w, h, colr) 
 4617   
 4618   
 4619  fl_oval_bound = fl_ovalbound 
 4620   
 4621   
 4622 -def fl_circf(x, y, r, colr): 
 4623      fl_oval(1, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr) 
 4624   
 4625   
 4626 -def fl_circ( x, y, r, colr): 
 4627      fl_oval(0, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr) 
 4628   
 4629   
 4630  # Arcs 
 4631   
 4632 -def fl_pieslice(fill, x, y, w, h, a1, a2, colr): 
 4633      """ fl_pieslice(fill, x, y, w, h, a1, a2, colr) 
 4634      """ 
 4635   
 4636      _fl_pieslice = cfuncproto( 
 4637              load_so_libforms(), "fl_pieslice",\ 
 4638              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4639              cty.c_int, cty.c_int, FL_COLOR],\ 
 4640              """void fl_pieslice(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 
 4641                 FL_Coord h, int a1, int a2, FL_COLOR col) 
 4642              """) 
 4643      check_admitted_listvalues(colr, COLOR_list) 
 4644      ifill = convert_to_int(fill) 
 4645      ix = convert_to_FL_Coord(x) 
 4646      iy = convert_to_FL_Coord(y) 
 4647      iw = convert_to_FL_Coord(w) 
 4648      ih = convert_to_FL_Coord(h) 
 4649      ia1 = convert_to_int(a1) 
 4650      ia2 = convert_to_int(a2) 
 4651      ulcolr = convert_to_FL_COLOR(colr) 
 4652      keep_elem_refs(fill, x, y, w, h, a1, a2, colr, ifill, ix, iy, iw, 
 4653                     ih, ia1, ia2, ulcolr) 
 4654      _fl_pieslice(ifill, ix, iy, iw, ih, ia1, ia2, ulcolr) 
 4655   
 4656   
 4657 -def fl_arcf(x, y, r, a1, a2, colr): 
 4658      fl_pieslice(1, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr) 
 4659   
 4660   
 4661 -def fl_arc(x, y, r, a1, a2, colr): 
 4662      fl_pieslice(0, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr) 
 4663   
 4664   
 4665  # High level drawing routines 
 4666   
 4667 -def fl_drw_frame(style, x, y, w, h, colr, bw): 
 4668      """ fl_drw_frame(style, x, y, w, h, colr, bw) 
 4669      """ 
 4670   
 4671      _fl_drw_frame = cfuncproto( 
 4672              load_so_libforms(), "fl_drw_frame",\ 
 4673              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4674              FL_COLOR, cty.c_int],\ 
 4675              """void fl_drw_frame(int style, FL_Coord x, FL_Coord y, 
 4676                 FL_Coord w, FL_Coord h, FL_COLOR c, int bw) 
 4677              """) 
 4678      check_admitted_listvalues(colr, COLOR_list) 
 4679      istyle = convert_to_int(style) 
 4680      ix = convert_to_FL_Coord(x) 
 4681      iy = convert_to_FL_Coord(y) 
 4682      iw = convert_to_FL_Coord(w) 
 4683      ih = convert_to_FL_Coord(h) 
 4684      ulcolr = convert_to_FL_COLOR(colr) 
 4685      ibw = convert_to_int(bw) 
 4686      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, 
 4687                     ih, ulcolr, ibw) 
 4688      _fl_drw_frame(istyle, ix, iy, iw, ih, ulcolr, ibw) 
 4689   
 4690   
 4691 -def fl_drw_checkbox(boxtype, x, y, w, h, colr, bw): 
 4692      """ fl_drw_checkbox(boxtype, x, y, w, h, colr, bw) 
 4693      """ 
 4694   
 4695      _fl_drw_checkbox = cfuncproto( 
 4696              load_so_libforms(), "fl_drw_checkbox",\ 
 4697              None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 
 4698              FL_COLOR, cty.c_int],\ 
 4699              """void fl_drw_checkbox(int type, FL_Coord x, FL_Coord y, 
 4700                 FL_Coord w, FL_Coord h, FL_COLOR col, int bw) 
 4701              """) 
 4702      check_admitted_listvalues(colr, COLOR_list) 
 4703      iboxtype = convert_to_int(boxtype) 
 4704      ix = convert_to_FL_Coord(x) 
 4705      iy = convert_to_FL_Coord(y) 
 4706      iw = convert_to_FL_Coord(w) 
 4707      ih = convert_to_FL_Coord(h) 
 4708      ulcolr = convert_to_FL_COLOR(colr) 
 4709      ibw = convert_to_int(bw) 
 4710      keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, 
 4711                     ih, ulcolr, ibw) 
 4712      _fl_drw_checkbox(iboxtype, ix, iy, iw, ih, ulcolr, ibw) 
 4713   
 4714   
 4715  # Interfaces 
 4716   
 4717 -def fl_get_fontstruct(style, size): 
 4718      """ fl_get_fontstruct(style, size) -> XFontStruct class 
 4719      """ 
 4720   
 4721      _fl_get_fontstruct = cfuncproto( 
 4722              load_so_libforms(), "fl_get_fontstruct",\ 
 4723              cty.POINTER(XFontStruct), [cty.c_int, cty.c_int],\ 
 4724              """)XFontStruct * fl_get_fontstruct(int style, int size) 
 4725              """) 
 4726      istyle = convert_to_int(style) 
 4727      isize = convert_to_int(size) 
 4728      keep_elem_refs(style, size, istyle, isize) 
 4729      retval = _fl_get_fontstruct(istyle, isize) 
 4730      return retval 
 4731   
 4732   
 4733  fl_get_font_struct = fl_get_fontstruct 
 4734  fl_get_fntstruct = fl_get_font_struct 
 4735   
 4736   
 4737  #def fl_get_mouse(x, y, keymask)       *API change* 
 4738 -def fl_get_mouse(): 
 4739      """ fl_get_mouse() -> window, x, y, keymask 
 4740      """ 
 4741   
 4742      _fl_get_mouse = cfuncproto( 
 4743              load_so_libforms(), "fl_get_mouse",\ 
 4744              Window, [cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 
 4745              cty.POINTER(cty.c_uint)],\ 
 4746              """Window fl_get_mouse(FL_Coord * x, FL_Coord * y, 
 4747                unsigned int * keymask) 
 4748              """) 
 4749      x, px = make_FL_Coord_and_pointer() 
 4750      y, py = make_FL_Coord_and_pointer() 
 4751      keymask, pkeymask = make_uint_and_pointer() 
 4752      keep_elem_refs(x, y, keymask, px, py, pkeymask) 
 4753      retval = _fl_get_mouse(px, py, pkeymask) 
 4754      return retval, x, y, keymask 
 4755   
 4756   
 4757 -def fl_set_mouse(mx, my): 
 4758      """ fl_set_mouse(mx, my) 
 4759      """ 
 4760   
 4761      _fl_set_mouse = cfuncproto( 
 4762              load_so_libforms(), "fl_set_mouse",\ 
 4763              None, [FL_Coord, FL_Coord],\ 
 4764              """void fl_set_mouse(FL_Coord mx, FL_Coord my) 
 4765              """) 
 4766      imx = convert_to_int(mx) 
 4767      imy = convert_to_int(my) 
 4768      keep_elem_refs(mx, my, imx, imy) 
 4769      _fl_set_mouse(imx, imy) 
 4770   
 4771   
 4772  #def fl_get_win_mouse(win, x, y, keymask)       *API change* 
 4773 -def fl_get_win_mouse(win): 
 4774      """ fl_get_win_mouse(win) -> window, x, y, keymask 
 4775      """ 
 4776   
 4777      _fl_get_win_mouse = cfuncproto( 
 4778              load_so_libforms(), "fl_get_win_mouse",\ 
 4779              Window, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 
 4780              cty.POINTER(cty.c_uint)],\ 
 4781              """Window fl_get_win_mouse(Window win, FL_Coord * x, FL_Coord * y, 
 4782              unsigned int * keymask) 
 4783              """) 
 4784      ulwin = convert_to_Window(win) 
 4785      x, px = make_FL_Coord_and_pointer() 
 4786      y, py = make_FL_Coord_and_pointer() 
 4787      keymask, pkeymask = make_uint_and_pointer() 
 4788      keep_elem_refs(win, x, y, keymask, ulwin, px, py, pkeymask) 
 4789      retval = _fl_get_win_mouse(ulwin, px, py, pkeymask) 
 4790      return retval, x, y, keymask 
 4791   
 4792   
 4793  #def fl_get_form_mouse(fm, x, y, keymask)       *API change* 
 4794 -def fl_get_form_mouse(pForm): 
 4795      """ fl_get_form_mouse(pForm) -> window, x, y, keymask 
 4796   
 4797          @param pForm : pointer to form 
 4798      """ 
 4799   
 4800      _fl_get_form_mouse = cfuncproto( 
 4801              load_so_libforms(), "fl_get_form_mouse",\ 
 4802              Window, [cty.POINTER(FL_FORM), cty.POINTER(FL_Coord),\ 
 4803              cty.POINTER(FL_Coord), cty.POINTER(cty.c_uint)],\ 
 4804              """Window fl_get_form_mouse(FL_FORM * fm, FL_Coord * x, 
 4805                 FL_Coord * y, unsigned int * keymask) 
 4806              """) 
 4807      x, px = make_FL_Coord_and_pointer() 
 4808      y, py = make_FL_Coord_and_pointer() 
 4809      keymask, pkeymask = make_uint_and_pointer() 
 4810      keep_elem_refs(pForm, x, y, keymask) 
 4811      retval = _fl_get_form_mouse(pForm, px, py, pkeymask) 
 4812      return retval, x, y, keymask 
 4813   
 4814   
 4815 -def fl_win_to_form(win): 
 4816      """ 
 4817          fl_win_to_form(win) -> pForm 
 4818   
 4819          Returns the form that's shown in win. 
 4820   
 4821          @param win  : window id whose form is shown 
 4822      """ 
 4823   
 4824      _fl_win_to_form = cfuncproto( 
 4825              load_so_libforms(), "fl_win_to_form", 
 4826              cty.POINTER(FL_FORM), [Window],\ 
 4827              """FL_FORM * fl_win_to_form(Window win) 
 4828              """) 
 4829      ulwin = convert_to_Window(win) 
 4830      keep_elem_refs(win, ulwin) 
 4831      retval = _fl_win_to_form(ulwin) 
 4832      return retval 
 4833   
 4834   
 4835 -def fl_set_form_icon(pForm, icon, mask): 
 4836      """ fl_set_form_icon(pForm, icon, mask) 
 4837   
 4838          @param pForm : pointer to form 
 4839      """ 
 4840   
 4841      _fl_set_form_icon = cfuncproto( 
 4842              load_so_libforms(), "fl_set_form_icon",\ 
 4843              None, [cty.POINTER(FL_FORM), Pixmap, Pixmap],\ 
 4844              """void fl_set_form_icon(FL_FORM * form, Pixmap p, Pixmap m) 
 4845              """) 
 4846      ulicon = convert_to_Pixmap(icon) 
 4847      ulmask = convert_to_Pixmap(mask) 
 4848      keep_elem_refs(pForm, icon, mask, ulicon, ulmask) 
 4849      _fl_set_form_icon(pForm, ulicon, ulmask) 
 4850   
 4851   
 4852  #def fl_get_decoration_sizes(pForm, top, right, bottom, left)       *API change* 
 4853 -def fl_get_decoration_sizes(pForm): 
 4854      """ 
 4855          fl_get_decoration_sizes(pForm) -> num., top, right, bottom, left 
 4856   
 4857          Returns the sizes of the "decorations" the window manager puts around 
 4858          a form's window. Returns 0 on success and 1 if the form isn't visible 
 4859          or it's a form embedded into another form. 
 4860   
 4861          @param pForm : pointer to form 
 4862      """ 
 4863   
 4864      _fl_get_decoration_sizes = cfuncproto( 
 4865              load_so_libforms(), "fl_get_decoration_sizes", 
 4866              cty.c_int, [cty.POINTER(FL_FORM), cty.POINTER(cty.c_int),\ 
 4867              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
 4868              cty.POINTER(cty.c_int)],\ 
 4869              """int fl_get_decoration_sizes(FL_FORM * form, int * top, 
 4870                 int * right, int * bottom, int * left) 
 4871              """) 
 4872      top, ptop = make_int_and_pointer() 
 4873      right, pright = make_int_and_pointer() 
 4874      bottom, pbottom = make_int_and_pointer() 
 4875      left, pleft = make_int_and_pointer() 
 4876      keep_elem_refs(pForm, top, right, bottom, left, ptop, pright, pbottom, 
 4877                     pleft) 
 4878      retval = _fl_get_decoration_sizes(pForm, ptop, pright, pbottom, pleft) 
 4879      return retval, top, right, bottom, left 
 4880   
 4881   
 4882 -def fl_raise_form(pForm): 
 4883      """ 
 4884           fl_raise_form(pForm) 
 4885   
 4886           @param pForm : pouinter to form to be raised 
 4887      """ 
 4888   
 4889      _fl_raise_form = cfuncproto( 
 4890              load_so_libforms(), "fl_raise_form",\ 
 4891              None, [cty.POINTER(FL_FORM)],\ 
 4892              """void fl_raise_form(FL_FORM * p1) 
 4893              """) 
 4894      keep_elem_refs(pForm) 
 4895      _fl_raise_form(pForm) 
 4896   
 4897   
 4898 -def fl_lower_form(pForm): 
 4899      """ 
 4900           fl_lower_form(pForm) 
 4901   
 4902           @param pForm : pouinter to form to be lowered 
 4903      """ 
 4904   
 4905      _fl_lower_form = cfuncproto( 
 4906              load_so_libforms(), "fl_lower_form",\ 
 4907              None, [cty.POINTER(FL_FORM)],\ 
 4908              """void fl_lower_form(FL_FORM * p1) 
 4909              """) 
 4910      keep_elem_refs(pForm) 
 4911      _fl_lower_form(pForm) 
 4912   
 4913   
 4914 -def fl_set_foreground(gc, colr): 
 4915      """ 
 4916          fl_set_foreground(gc, colr) 
 4917   
 4918          @param gc : ? 
 4919          @param colr : color value to be set as foreground 
 4920      """ 
 4921   
 4922      _fl_set_foreground = cfuncproto( 
 4923              load_so_libforms(), "fl_set_foreground",\ 
 4924              None, [GC, FL_COLOR],\ 
 4925              """oid fl_set_foreground(GC gc, FL_COLOR col) 
 4926              """) 
 4927      ulcolr = convert_to_FL_COLOR(colr) 
 4928      keep_elem_refs(gc, colr, ulcolr) 
 4929      _fl_set_foreground(gc, ulcolr) 
 4930   
 4931   
 4932 -def fl_set_background(gc, colr): 
 4933      """ 
 4934          fl_set_background(gc, colr) 
 4935   
 4936          @param gc : ? 
 4937          @param colr : color value to be set as background 
 4938      """ 
 4939   
 4940      _fl_set_background = cfuncproto( 
 4941              load_so_libforms(), "fl_set_background",\ 
 4942              None, [GC, FL_COLOR],\ 
 4943              """oid fl_set_background(GC gc, FL_COLOR col) 
 4944              """) 
 4945      ulcolr = convert_to_FL_COLOR(colr) 
 4946      keep_elem_refs(gc, colr, ulcolr) 
 4947      _fl_set_background(gc, ulcolr) 
 4948   
 4949   
 4950  # General windowing support 
 4951   
 4952 -def fl_wincreate(title): 
 4953      """ 
 4954          fl_wincreate(title) -> window ID 
 4955   
 4956          Creates a window with a specified title. 
 4957   
 4958          @param title : title of the window 
 4959      """ 
 4960   
 4961      _fl_wincreate = cfuncproto( 
 4962              load_so_libforms(), "fl_wincreate",\ 
 4963              Window, [STRING],\ 
 4964              """Window fl_wincreate(const char * label) 
 4965              """) 
 4966      stitle = convert_to_string(title) 
 4967      keep_elem_refs(title, stitle) 
 4968      retval = _fl_wincreate(stitle) 
 4969      return retval 
 4970   
 4971   
 4972 -def fl_winshow(win): 
 4973      """ 
 4974          fl_winshow(win) -> window 
 4975   
 4976          Shows the window (created with fl_wincreate) 
 4977   
 4978          @param win : window id to show 
 4979      """ 
 4980   
 4981      _fl_winshow = cfuncproto( 
 4982              load_so_libforms(), "fl_winshow",\ 
 4983              Window, [Window],\ 
 4984              """Window fl_winshow(Window win) 
 4985              """) 
 4986      ulwin = convert_to_Window(win) 
 4987      keep_elem_refs(win, ulwin) 
 4988      retval = _fl_winshow(ulwin) 
 4989      return retval 
 4990   
 4991   
 4992 -def fl_winopen(title): 
 4993      """ 
 4994          fl_winopen(title) -> window 
 4995          Opens (creates and shows) a toplevel window with the specified 
 4996          title. 
 4997   
 4998          @param title : title of the window 
 4999      """ 
 5000   
 5001      _fl_winopen = cfuncproto( 
 5002              load_so_libforms(), "fl_winopen", \ 
 5003              Window, [STRING], \ 
 5004              """Window fl_winopen(const char * label) 
 5005              """) 
 5006      stitle = convert_to_string(title) 
 5007      keep_elem_refs(title, stitle) 
 5008      retval = _fl_winopen(stitle) 
 5009      return retval 
 5010   
 5011   
 5012 -def fl_winhide(win): 
 5013      """ fl_winhide(win) 
 5014      """ 
 5015   
 5016      _fl_winhide = cfuncproto( 
 5017              load_so_libforms(), "fl_winhide", \ 
 5018              None, [Window], \ 
 5019              """void fl_winhide(Window win) 
 5020              """) 
 5021      ulwin = convert_to_Window(win) 
 5022      keep_elem_refs(win, ulwin) 
 5023      _fl_winhide(ulwin) 
 5024   
 5025   
 5026 -def fl_winclose(win): 
 5027      """ fl_winclose(win) 
 5028      """ 
 5029   
 5030      _fl_winclose = cfuncproto( 
 5031              load_so_libforms(), "fl_winclose", \ 
 5032              None, [Window], \ 
 5033              """void fl_winclose(Window win) 
 5034              """) 
 5035      ulwin = convert_to_Window(win) 
 5036      keep_elem_refs(win, ulwin) 
 5037      _fl_winclose(win, ulwin) 
 5038   
 5039   
 5040 -def fl_winset(win): 
 5041      """ fl_winset(win) 
 5042      """ 
 5043   
 5044      _fl_winset = cfuncproto( 
 5045              load_so_libforms(), "fl_winset", \ 
 5046              None, [Window], \ 
 5047              """void fl_winset(Window win) 
 5048              """) 
 5049      ulwin = convert_to_Window(win) 
 5050      keep_elem_refs(win, ulwin) 
 5051      _fl_winset(ulwin) 
 5052   
 5053   
 5054 -def fl_winreparent(win, winnewparent): 
 5055      """ 
 5056          fl_winreparent(win, winnewparent) -> num. 
 5057   
 5058          Makes a toplevel window a subwindow of another (new parent) window; 
 5059          both the window and the parent window must be valid ones. 
 5060   
 5061          @param win : window to be made a subwindow 
 5062          @param winnewparent : window to become its new parent window 
 5063      """ 
 5064   
 5065      _fl_winreparent = cfuncproto( 
 5066              load_so_libforms(), "fl_winreparent", \ 
 5067              cty.c_int, [Window, Window], \ 
 5068              """int fl_winreparent(Window win, Window new_parent) 
 5069              """) 
 5070      ulwin = convert_to_Window(win) 
 5071      ulwinnewparent = convert_to_Window(winnewparent) 
 5072      keep_elem_refs(win, winnewparent, ulwin, ulwinnewparent) 
 5073      retval = _fl_winreparent(ulwin, ulwinnewparent) 
 5074      return retval 
 5075   
 5076   
 5077 -def fl_winfocus(win): 
 5078      """ fl_winfocus(win) 
 5079      """ 
 5080   
 5081      _fl_winfocus = cfuncproto( 
 5082              load_so_libforms(), "fl_winfocus", \ 
 5083              None, [Window], \ 
 5084              """void fl_winfocus(Window win) 
 5085              """) 
 5086      ulwin = convert_to_Window(win) 
 5087      keep_elem_refs(win, ulwin) 
 5088      _fl_winfocus(ulwin) 
 5089   
 5090   
 5091 -def fl_winget(): 
 5092      """ fl_winget() -> window 
 5093      """ 
 5094   
 5095      _fl_winget = cfuncproto( 
 5096              load_so_libforms(), "fl_winget", \ 
 5097              Window, [], \ 
 5098              """Window fl_winget() 
 5099              """) 
 5100      retval = _fl_winget() 
 5101      return retval 
 5102   
 5103   
 5104 -def fl_iconify(win): 
 5105      """ fl_iconify(win) -> num. 
 5106      """ 
 5107   
 5108      _fl_iconify = cfuncproto( 
 5109              load_so_libforms(), "fl_iconify", \ 
 5110              cty.c_int, [Window], \ 
 5111              """int fl_iconify(Window win) 
 5112              """) 
 5113      ulwin = convert_to_Window(win) 
 5114      keep_elem_refs(win, ulwin) 
 5115      retval = _fl_iconify(ulwin) 
 5116      return retval 
 5117   
 5118   
 5119 -def fl_winresize(win, neww, newh): 
 5120      """ fl_winresize(win, neww, newh) 
 5121   
 5122          @param win : window to resize 
 5123          @param neww : new width 
 5124          @param newh : new height 
 5125      """ 
 5126   
 5127      _fl_winresize = cfuncproto( 
 5128              load_so_libforms(), "fl_winresize", \ 
 5129              None, [Window, FL_Coord, FL_Coord], \ 
 5130              """void fl_winresize(Window win, FL_Coord neww, FL_Coord newh) 
 5131              """) 
 5132      ulwin = convert_to_Window(win) 
 5133      ineww = convert_to_int(neww) 
 5134      inewh = convert_to_int(newh) 
 5135      keep_elem_refs(win, neww, newh, ulwin, ineww, inewh) 
 5136      _fl_winresize(ulwin, ineww, inewh) 
 5137   
 5138   
 5139 -def fl_winmove(win, dx, dy): 
 5140      """ 
 5141          fl_winmove(win, dx, dy) 
 5142   
 5143          Moves a window to a new position. 
 5144   
 5145          @param win : window to move to a new position 
 5146          @param dx : new horizontal position 
 5147          @param dy : new vertical position 
 5148      """ 
 5149   
 5150      _fl_winmove = cfuncproto( 
 5151              load_so_libforms(), "fl_winmove", \ 
 5152              None, [Window, FL_Coord, FL_Coord], \ 
 5153              """void fl_winmove(Window win, FL_Coord dx, FL_Coord dy) 
 5154              """) 
 5155      ulwin = convert_to_Window(win) 
 5156      idx = convert_to_int(dx) 
 5157      idy = convert_to_int(dy) 
 5158      keep_elem_refs(win, dx, dy, ulwin, idx, idy) 
 5159      _fl_winmove(ulwin, idx, idy) 
 5160   
 5161   
 5162 -def fl_winreshape(win, dx, dy, w, h): 
 5163      """ fl_winreshape(win, dx, dy, w, h) 
 5164      """ 
 5165   
 5166      _fl_winreshape = cfuncproto( 
 5167              load_so_libforms(), "fl_winreshape", \ 
 5168              None, [Window, FL_Coord, FL_Coord, FL_Coord, FL_Coord], \ 
 5169              """void fl_winreshape(Window win, FL_Coord dx, FL_Coord dy, 
 5170                 FL_Coord w, FL_Coord h) 
 5171              """) 
 5172      ulwin = convert_to_Window(win) 
 5173      idx = convert_to_int(dx) 
 5174      idy = convert_to_int(dy) 
 5175      iw = convert_to_FL_Coord(w) 
 5176      ih = convert_to_FL_Coord(h) 
 5177      keep_elem_refs(win, dx, dy, w, h, ulwin, idx, idy, iw, ih) 
 5178      _fl_winreshape(ulwin, idx, idy, iw, ih) 
 5179   
 5180   
 5181 -def fl_winicon(win, icon, mask): 
 5182      """ 
 5183          fl_winicon(win, icon, mask) 
 5184   
 5185          Installs an icon for the window. 
 5186   
 5187          @param win : window 
 5188          @param icon : pixmap icon to be installed in window 
 5189          @param mask : mask 
 5190      """ 
 5191   
 5192      _fl_winicon = cfuncproto( 
 5193              load_so_libforms(), "fl_winicon", \ 
 5194              None, [Window, Pixmap, Pixmap], \ 
 5195              """void fl_winicon(Window win, Pixmap p, Pixmap m) 
 5196              """) 
 5197      ulwin = convert_to_Window(win) 
 5198      ulicon = convert_to_Pixmap(icon) 
 5199      ulmask = convert_to_Pixmap(mask) 
 5200      keep_elem_refs(win, icon, mask, ulwin, ulicon, ulmask) 
 5201      _fl_winicon(ulwin, ulicon, ulmask) 
 5202   
 5203   
 5204 -def fl_winbackground(win, bkcolr): 
 5205      """ 
 5206          fl_winbackground(win, bkcolr) 
 5207   
 5208          Sets the background of the window to a certain color. 
 5209   
 5210          @param win : window 
 5211          @param bkcolr : background color to be set 
 5212      """ 
 5213   
 5214      _fl_winbackground = cfuncproto( 
 5215              load_so_libforms(), "fl_winbackground", \ 
 5216              None, [Window, FL_COLOR], \ 
 5217              """void fl_winbackground(Window win, FL_COLOR bk) 
 5218              """) 
 5219      check_admitted_listvalues(bkcolr, COLOR_list) 
 5220      ulwin = convert_to_Window(win) 
 5221      ulbkcolr = convert_to_FL_COLOR(bkcolr) 
 5222      keep_elem_refs(win, bkcolr, ulwin, ulbkcolr) 
 5223      _fl_winbackground(ulwin, ulbkcolr) 
 5224   
 5225   
 5226 -def fl_winstepsize(win, dx, dy): 
 5227      """ fl_winstepsize(win, dx, dy) 
 5228      """ 
 5229   
 5230      _fl_winstepsize = cfuncproto( 
 5231              load_so_libforms(), "fl_winstepsize", \ 
 5232              None, [Window, FL_Coord, FL_Coord], \ 
 5233              """void fl_winstepsize(Window win, FL_Coord dx, FL_Coord dy) 
 5234              """) 
 5235      ulwin = convert_to_Window(win) 
 5236      idx = convert_to_int(dx) 
 5237      idy = convert_to_int(dy) 
 5238      keep_elem_refs(win, dx, dy, ulwin, idx, idy) 
 5239      _fl_winstepsize(ulwin, idx, idy) 
 5240   
 5241   
 5242  fl_winstepunit = fl_winstepsize 
 5243  fl_set_winstepunit = fl_winstepsize 
 5244   
 5245   
 5246 -def fl_winisvalid(win): 
 5247      """ 
 5248          fl_winisvalid(win) -> num. 
 5249   
 5250          Returns if a window is a valid one. 
 5251   
 5252          @param win : window to evaluate 
 5253      """ 
 5254   
 5255      _fl_winisvalid = cfuncproto( 
 5256              load_so_libforms(), "fl_winisvalid", \ 
 5257              cty.c_int, [Window], \ 
 5258              """int fl_winisvalid(Window win) 
 5259              """) 
 5260      ulwin = convert_to_Window(win) 
 5261      keep_elem_refs(win, ulwin) 
 5262      retval = _fl_winisvalid(ulwin) 
 5263      return retval 
 5264   
 5265   
 5266 -def fl_wintitle(win, title): 
 5267      """ 
 5268          fl_wintitle(win, title) 
 5269   
 5270          Changes the window title (and its associated icon title). 
 5271   
 5272          @param win : window 
 5273          @param title : window title to be set 
 5274      """ 
 5275   
 5276      _fl_wintitle = cfuncproto( 
 5277              load_so_libforms(), "fl_wintitle", \ 
 5278              None, [Window, STRING], \ 
 5279              """void fl_wintitle(Window win, const char * title) 
 5280              """) 
 5281      ulwin = convert_to_Window(win) 
 5282      stitle = convert_to_string(title) 
 5283      keep_elem_refs(win, title, ulwin, stitle) 
 5284      _fl_wintitle(ulwin, stitle) 
 5285   
 5286   
 5287 -def fl_winicontitle(win, title): 
 5288      """ 
 5289          fl_winicontitle(win, title) 
 5290   
 5291          Changes only the icon title for the window. 
 5292   
 5293          @param win : window 
 5294          @param title : icon title to be set 
 5295      """ 
 5296   
 5297      _fl_winicontitle = cfuncproto( 
 5298              load_so_libforms(), "fl_winicontitle", \ 
 5299              None, [Window, STRING], \ 
 5300              """void fl_winicontitle(Window win, const char * title) 
 5301              """) 
 5302      ulwin = convert_to_Window(win) 
 5303      stitle = convert_to_string(title) 
 5304      keep_elem_refs(win, title, ulwin, stitle) 
 5305      _fl_winicontitle(ulwin, stitle) 
 5306   
 5307   
 5308 -def fl_winposition(x, y): 
 5309      """ 
 5310          fl_winposition(x, y) 
 5311   
 5312          Sets the position of a window to be opened. 
 5313   
 5314          @param x : horizontal position of the window (upper-left corner) 
 5315          @param y : vertical position of the window (upper-left corner) 
 5316      """ 
 5317   
 5318      _fl_winposition = cfuncproto( 
 5319              load_so_libforms(), "fl_winposition", 
 5320              None, [FL_Coord, FL_Coord], 
 5321              """void fl_winposition(FL_Coord x, FL_Coord y) 
 5322              """) 
 5323      ix = convert_to_FL_Coord(x) 
 5324      iy = convert_to_FL_Coord(y) 
 5325      keep_elem_refs(x, y, ix, iy) 
 5326      _fl_winposition(ix, iy) 
 5327   
 5328   
 5329  fl_pref_winposition = fl_winposition 
 5330  fl_win_background = fl_winbackground 
 5331  fl_set_winstepunit = fl_winstepunit 
 5332   
 5333   
 5334 -def fl_winminsize(win, w, h): 
 5335      """ 
 5336          fl_winminsize(win, w, h) 
 5337   
 5338          Sets a constraint for a resizable window whose size will be within a 
 5339          range not less than minumum (to be used before calling fl_winopen). 
 5340   
 5341          @param win : window to be set 
 5342          @param w : minimum width of window 
 5343          @param h : minimum height of window 
 5344      """ 
 5345   
 5346      _fl_winminsize = cfuncproto( 
 5347              load_so_libforms(), "fl_winminsize", 
 5348              None, [Window, FL_Coord, FL_Coord], 
 5349              """void fl_winminsize(Window win, FL_Coord w, FL_Coord h) 
 5350              """) 
 5351      ulwin = convert_to_Window(win) 
 5352      iw = convert_to_FL_Coord(w) 
 5353      ih = convert_to_FL_Coord(h) 
 5354      keep_elem_refs(win, w, h, ulwin, iw, ih) 
 5355      _fl_winminsize(ulwin, iw, ih) 
 5356   
 5357   
 5358 -def fl_winmaxsize(win, w, h): 
 5359      """ 
 5360          fl_winmaxsize(win, w, h) 
 5361   
 5362          Sets a constraint for a resizable window whose size will be within a 
 5363          range not bigger than maximum (before calling fl_winopen). 
 5364   
 5365          @param win : window to be set 
 5366          @param w : maximum width of window 
 5367          @param h : maximum height of window 
 5368      """ 
 5369   
 5370      _fl_winmaxsize = cfuncproto( 
 5371              load_so_libforms(), "fl_winmaxsize", 
 5372              None, [Window, FL_Coord, FL_Coord], 
 5373              """void fl_winmaxsize(Window win, FL_Coord w, FL_Coord h) 
 5374              """) 
 5375      ulwin = convert_to_Window(win) 
 5376      iw = convert_to_FL_Coord(w) 
 5377      ih = convert_to_FL_Coord(h) 
 5378      keep_elem_refs(win, w, h, ulwin, iw, ih) 
 5379      _fl_winmaxsize(ulwin, iw, ih) 
 5380   
 5381   
 5382 -def fl_winaspect(win, x, y): 
 5383      """ 
 5384          fl_winaspect(win, x, y) 
 5385   
 5386          Sets the aspect ratio of the window for later interactive resizing. 
 5387   
 5388          @param win : window to be set 
 5389          @param x : horizontal aspect ratio 
 5390          @param y : vertical aspect ratio 
 5391      """ 
 5392   
 5393      _fl_winaspect = cfuncproto( 
 5394              load_so_libforms(), "fl_winaspect", 
 5395              None, [Window, FL_Coord, FL_Coord], 
 5396              """void fl_winaspect(Window win, FL_Coord x, FL_Coord y) 
 5397              """) 
 5398      ulwin = convert_to_Window(win) 
 5399      ix = convert_to_FL_Coord(x) 
 5400      iy = convert_to_FL_Coord(y) 
 5401      keep_elem_refs(win, x, y, ulwin, ix, iy) 
 5402      _fl_winaspect(ulwin, ix, iy) 
 5403   
 5404   
 5405 -def fl_reset_winconstraints(win): 
 5406      """ fl_reset_winconstraints(win) 
 5407      """ 
 5408   
 5409      _fl_reset_winconstraints = cfuncproto( 
 5410              load_so_libforms(), "fl_reset_winconstraints", 
 5411              None, [Window], 
 5412              """void fl_reset_winconstraints(Window win) 
 5413              """) 
 5414      ulwin = convert_to_Window(win) 
 5415      keep_elem_refs(win) 
 5416      _fl_reset_winconstraints(ulwin) 
 5417   
 5418   
 5419 -def fl_winsize(w, h): 
 5420      """ 
 5421          fl_winsize(w, h) 
 5422   
 5423          Sets the preferred window size (before calling fl_winopen), and makes 
 5424          the window non-resizeable. 
 5425   
 5426          @param w : width of the window in pixels 
 5427          @param h : height of the window in pixels 
 5428      """ 
 5429   
 5430      _fl_winsize = cfuncproto( 
 5431              load_so_libforms(), "fl_winsize", 
 5432              None, [FL_Coord, FL_Coord], 
 5433              """void fl_winsize(FL_Coord w, FL_Coord h) 
 5434              """) 
 5435      iw = convert_to_FL_Coord(w) 
 5436      ih = convert_to_FL_Coord(h) 
 5437      keep_elem_refs(w, h, iw, ih) 
 5438      _fl_winsize(iw, ih) 
 5439   
 5440   
 5441 -def fl_initial_winsize(w, h): 
 5442      """ 
 5443          fl_initial_winsize(w, h) 
 5444   
 5445          Sets the preferred window size (before calling fl_winopen). 
 5446   
 5447          @param w : width of the window in pixels 
 5448          @param h : height of the window in pixels 
 5449      """ 
 5450   
 5451      _fl_initial_winsize = cfuncproto( 
 5452              load_so_libforms(), "fl_initial_winsize", 
 5453              None, [FL_Coord, FL_Coord], 
 5454              """void fl_initial_winsize(FL_Coord w, FL_Coord h) 
 5455              """) 
 5456      iw = convert_to_FL_Coord(w) 
 5457      ih = convert_to_FL_Coord(h) 
 5458      keep_elem_refs(w, h, iw, ih) 
 5459      _fl_initial_winsize(iw, ih) 
 5460   
 5461   
 5462  fl_pref_winsize = fl_winsize 
 5463   
 5464   
 5465 -def fl_initial_winstate(state): 
 5466      """ fl_initial_winstate(state) 
 5467      """ 
 5468   
 5469      _fl_initial_winstate = cfuncproto( 
 5470              load_so_libforms(), "fl_initial_winstate", 
 5471              None, [cty.c_int], 
 5472              """void fl_initial_winstate(int state) 
 5473              """) 
 5474      istate = convert_to_int(state) 
 5475      keep_elem_refs(state, istate) 
 5476      _fl_initial_winstate(istate) 
 5477   
 5478   
 5479 -def fl_create_colormap(pXVisualInfo, nfill): 
 5480      """ fl_create_colormap(pXVisualInfo, nfill) -> colormap 
 5481      """ 
 5482   
 5483      _fl_create_colormap = cfuncproto( 
 5484              load_so_libforms(), "fl_create_colormap", 
 5485              Colormap, [cty.POINTER(XVisualInfo), cty.c_int], 
 5486              """)Colormap fl_create_colormap(XVisualInfo * xv, int nfill) 
 5487              """) 
 5488      infill = convert_to_int(nfill) 
 5489      keep_elem_refs(pXVisualInfo, nfill, infill) 
 5490      retval = _fl_create_colormap(pXVisualInfo, infill) 
 5491      return retval 
 5492   
 5493   
 5494 -def fl_wingeometry(x, y, w, h): 
 5495      """ 
 5496          fl_wingeometry(x, y, w, h) 
 5497   
 5498          Sets the initial geometry (position and size) of the window to be 
 5499          opened; the window will not be resizable. 
 5500   
 5501          @param x : horizontal position of the window (upper-left corner) 
 5502          @param y : vertical position of the window (upper-left corner) 
 5503          @param w : width of the window in pixels 
 5504          @param h : height of the window in pixels 
 5505      """ 
 5506   
 5507      _fl_wingeometry = cfuncproto( 
 5508              load_so_libforms(), "fl_wingeometry", 
 5509              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 5510              """void fl_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, 
 5511                 FL_Coord h) 
 5512              """) 
 5513      ix = convert_to_FL_Coord(x) 
 5514      iy = convert_to_FL_Coord(y) 
 5515      iw = convert_to_FL_Coord(w) 
 5516      ih = convert_to_FL_Coord(h) 
 5517      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 5518      _fl_wingeometry(ix, iy, iw, ih) 
 5519   
 5520   
 5521  fl_pref_wingeometry = fl_wingeometry 
 5522   
 5523   
 5524 -def fl_initial_wingeometry(x, y, w, h): 
 5525      """ 
 5526          fl_initial_wingeometry(x, y, w, h) 
 5527   
 5528          Sets the initial geometry (position and size) of the window to be 
 5529          opened. 
 5530   
 5531          @param x : horizontal position of the window (upper-left corner) 
 5532          @param y : vertical position of the window (upper-left corner) 
 5533          @param w : width of the window in pixels 
 5534          @param h : height of the window in pixels 
 5535      """ 
 5536   
 5537      _fl_initial_wingeometry = cfuncproto( 
 5538              load_so_libforms(), "fl_initial_wingeometry", 
 5539              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 5540              """void fl_initial_wingeometry(FL_Coord x, FL_Coord y, 
 5541                 FL_Coord w, FL_Coord h) 
 5542              """) 
 5543      ix = convert_to_FL_Coord(x) 
 5544      iy = convert_to_FL_Coord(y) 
 5545      iw = convert_to_FL_Coord(w) 
 5546      ih = convert_to_FL_Coord(h) 
 5547      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 5548      _fl_initial_wingeometry(ix, iy, iw, ih) 
 5549   
 5550   
 5551 -def fl_noborder(): 
 5552      """ 
 5553          fl_noborder() 
 5554   
 5555          Suppresses the window manager's decoration (before creating the 
 5556          window). 
 5557      """ 
 5558   
 5559      _fl_noborder = cfuncproto( 
 5560              load_so_libforms(), "fl_noborder", 
 5561              None, [], 
 5562              """void fl_noborder() 
 5563              """) 
 5564      _fl_noborder() 
 5565   
 5566   
 5567 -def fl_transient(): 
 5568      """ 
 5569          fl_transient() 
 5570   
 5571          Makes a window a transient one (before creating the window). 
 5572      """ 
 5573   
 5574      _fl_transient = cfuncproto( 
 5575              load_so_libforms(), "fl_transient", 
 5576              None, [], \ 
 5577              """void fl_transient() 
 5578              """) 
 5579      _fl_transient() 
 5580   
 5581   
 5582  #def fl_get_winsize(win, w, h)       *API change* 
 5583 -def fl_get_winsize(win): 
 5584      """ fl_get_winsize(win) -> width, height 
 5585   
 5586          @param win : window 
 5587      """ 
 5588   
 5589      _fl_get_winsize = cfuncproto( 
 5590              load_so_libforms(), "fl_get_winsize", 
 5591              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5592              """void fl_get_winsize(Window win, FL_Coord * w, FL_Coord * h) 
 5593              """) 
 5594      ulwin = convert_to_Window(win) 
 5595      iw, pw = make_int_and_pointer() 
 5596      ih, ph = make_int_and_pointer() 
 5597      keep_elem_refs(win, ulwin, iw, ih, pw, ph) 
 5598      _fl_get_winsize(ulwin, pw, ph) 
 5599      return iw, ih 
 5600   
 5601   
 5602  #def fl_get_winorigin(win, x, y)       *API change* 
 5603 -def fl_get_winorigin(win): 
 5604      """ fl_get_winorigin(win) -> x, y 
 5605      """ 
 5606   
 5607      _fl_get_winorigin = cfuncproto( 
 5608              load_so_libforms(), "fl_get_winorigin", 
 5609              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5610              """void fl_get_winorigin(Window win, FL_Coord * x, FL_Coord * y) 
 5611              """) 
 5612      ulwin = convert_to_Window(win) 
 5613      x, px = make_FL_Coord_and_pointer() 
 5614      y, py = make_FL_Coord_and_pointer() 
 5615      keep_elem_refs(win, ulwin, x, y, px, py) 
 5616      _fl_get_winorigin(win, px, py) 
 5617      return x, y 
 5618   
 5619   
 5620  #def fl_get_wingeometry(win, x, y, w, h)       *API change* 
 5621 -def fl_get_wingeometry(win): 
 5622      """ 
 5623          fl_get_wingeometry(win) -> x, y, w, h 
 5624   
 5625          Returns geometry (position and size) of a window. 
 5626   
 5627          @param win : window 
 5628      """ 
 5629   
 5630      _fl_get_wingeometry = cfuncproto( 
 5631              load_so_libforms(), "fl_get_wingeometry", 
 5632              None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 5633              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 
 5634              """void fl_get_wingeometry(Window win, FL_Coord * x, FL_Coord * y, 
 5635                 FL_Coord * w, FL_Coord * h) 
 5636              """) 
 5637      ulwin = convert_to_Window(win) 
 5638      x, px = make_FL_Coord_and_pointer() 
 5639      y, py = make_FL_Coord_and_pointer() 
 5640      w, pw = make_FL_Coord_and_pointer() 
 5641      h, ph = make_FL_Coord_and_pointer() 
 5642      keep_elem_refs(win, x, y, w, h, ulwin, px, py, pw, ph) 
 5643      _fl_get_wingeometry(ulwin, px, py, pw, ph) 
 5644      return x, y, w, h 
 5645   
 5646   
 5647  # For compatibility 
 5648  fl_get_win_size = fl_get_winsize 
 5649  fl_get_win_origin = fl_get_winorigin 
 5650  fl_get_win_geometry = fl_get_wingeometry 
 5651  fl_initial_winposition = fl_pref_winposition 
 5652   
 5653   
 5654 -def fl_get_display():       # NOT SURE 
 5655      return fl_display 
 5656   
 5657   
 5658 -def FL_FormDisplay(pForm):   # NOT SURE 
 5659      return fl_display 
 5660   
 5661   
 5662 -def FL_ObjectDisplay(object):   # NOT SURE 
 5663      return fl_display 
 5664   
 5665   
 5666 -def FL_IS_CANVAS(pObject): 
 5667      if (pObject.contents.objclass == FL_CANVAS) or \ 
 5668          (pObject.contents.objclass == FL_GLCANVAS): 
 5669          return True 
 5670      else: 
 5671          return False 
 5672   
 5673   
 5674  # The window an object belongs to - for drawing 
 5675 -def FL_ObjWin(pObject): 
 5676      if FL_IS_CANVAS(pObject): 
 5677          return fl_get_canvas_id(pObject) 
 5678      else: 
 5679          return pObject.contents.form.contents.window 
 5680   
 5681   
 5682 -def fl_get_real_object_window(pObject): 
 5683      """ fl_get_real_object_window(pObject) -> window 
 5684   
 5685          @param pObject : pointer to object 
 5686      """ 
 5687   
 5688      _fl_get_real_object_window = cfuncproto( 
 5689              load_so_libforms(), "fl_get_real_object_window", 
 5690              Window, [cty.POINTER(FL_OBJECT)], 
 5691              """Window fl_get_real_object_window(FL_OBJECT * ob) 
 5692              """) 
 5693      keep_elem_refs(pObject) 
 5694      retval = _fl_get_real_object_window(pObject) 
 5695      return retval 
 5696   
 5697   
 5698  FL_OBJECT_WID = FL_ObjWin 
 5699   
 5700   
 5701  # Replacements for X functions that access the event queue 
 5702   
 5703 -def fl_XNextEvent(pXEvent): 
 5704      """ fl_XNextEvent(pXEvent) -> event num. 
 5705      """ 
 5706   
 5707      _fl_XNextEvent = cfuncproto( 
 5708              load_so_libforms(), "fl_XNextEvent", 
 5709              cty.c_int, [cty.POINTER(XEvent)], 
 5710              """int fl_XNextEvent(XEvent * xev) 
 5711              """) 
 5712      keep_elem_refs(pXEvent) 
 5713      retval = _fl_XNextEvent(pXEvent) 
 5714      return retval 
 5715   
 5716   
 5717 -def fl_XPeekEvent(pXEvent): 
 5718      """ fl_XPeekEvent(pXEvent) -> event num. 
 5719      """ 
 5720   
 5721      _fl_XPeekEvent = cfuncproto( 
 5722              load_so_libforms(), "fl_XPeekEvent", 
 5723              cty.c_int, [cty.POINTER(XEvent)], 
 5724              """int fl_XPeekEvent(XEvent * xev) 
 5725              """) 
 5726      keep_elem_refs(pXEvent) 
 5727      retval = _fl_XPeekEvent(pXEvent) 
 5728      return retval 
 5729   
 5730   
 5731 -def fl_XEventsQueued(mode): 
 5732      """ fl_XEventsQueued(mode) -> event num. 
 5733      """ 
 5734   
 5735      _fl_XEventsQueued = cfuncproto( 
 5736              load_so_libforms(), "fl_XEventsQueued", 
 5737              cty.c_int, [cty.c_int], 
 5738              """int fl_XEventsQueued(int mode) 
 5739              """) 
 5740      imode = convert_to_int(mode) 
 5741      keep_elem_refs(mode, imode) 
 5742      retval = _fl_XEventsQueued(imode) 
 5743      return retval 
 5744   
 5745   
 5746 -def fl_XPutBackEvent(pXEvent): 
 5747      """ fl_XPutBackEvent(pXEvent) 
 5748      """ 
 5749   
 5750      _fl_XPutBackEvent = cfuncproto( 
 5751              load_so_libforms(), "fl_XPutBackEvent", 
 5752              None, [cty.POINTER(XEvent)], 
 5753              """void fl_XPutBackEvent(XEvent * xev) 
 5754              """) 
 5755      keep_elem_refs(pXEvent) 
 5756      _fl_XPutBackEvent(pXEvent) 
 5757   
 5758   
 5759 -def fl_last_event(): 
 5760      """ fl_last_event() -> event 
 5761      """ 
 5762   
 5763      _fl_last_event = cfuncproto( 
 5764              load_so_libforms(), "fl_last_event", 
 5765              cty.POINTER(XEvent), [], 
 5766              """const char * fl_last_event() 
 5767              """) 
 5768      retval = _fl_last_event() 
 5769      return retval 
 5770   
 5771   
 5772  FL_APPEVENT_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 
 5773   
 5774 -def fl_set_event_callback(py_AppEventCb, userdata): 
 5775      """ 
 5776          fl_set_event_callback(py_AppEventCb, userdata) -> event callback 
 5777      """ 
 5778   
 5779      _fl_set_event_callback = cfuncproto( 
 5780              load_so_libforms(), "fl_set_event_callback", 
 5781              FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 
 5782              """FL_APPEVENT_CB fl_set_event_callback(FL_APPEVENT_CB callback, 
 5783                 void * user_data) 
 5784              """) 
 5785      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5786      puserdata = cty.cast(userdata, cty.c_void_p) 
 5787      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5788      keep_elem_refs(userdata, puserdata) 
 5789      retval = _fl_set_event_callback(c_AppEventCb, puserdata) 
 5790      return retval 
 5791   
 5792   
 5793 -def fl_set_idle_callback(py_AppEventCb, userdata): 
 5794      """ fl_set_idle_callback(py_AppEventCb, userdata) -> event callback func. 
 5795      """ 
 5796   
 5797      _fl_set_idle_callback = cfuncproto( 
 5798              load_so_libforms(), "fl_set_idle_callback", 
 5799              FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 
 5800              """FL_APPEVENT_CB fl_set_idle_callback(FL_APPEVENT_CB callback, 
 5801                 void * user_data) 
 5802              """) 
 5803      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5804      puserdata = cty.cast(userdata, cty.c_void_p) 
 5805      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5806      keep_elem_refs(userdata, puserdata) 
 5807      retval = _fl_set_idle_callback(c_AppEventCb, puserdata) 
 5808      return retval 
 5809   
 5810   
 5811 -def fl_addto_selected_xevent(win, mask): 
 5812      """ fl_addto_selected_xevent(win, mask) -> num. 
 5813      """ 
 5814   
 5815      _fl_addto_selected_xevent = cfuncproto( 
 5816              load_so_libforms(), "fl_addto_selected_xevent", 
 5817              cty.c_long, [Window, cty.c_long], 
 5818              """long int fl_addto_selected_xevent(Window win, long int mask) 
 5819              """) 
 5820      ulwin = convert_to_Window(win) 
 5821      lmask = convert_to_long(mask) 
 5822      keep_elem_refs(win, mask, ulwin, lmask) 
 5823      retval = _fl_addto_selected_xevent(ulwin, lmask) 
 5824      return retval 
 5825   
 5826   
 5827 -def fl_remove_selected_xevent(win, mask): 
 5828      """ fl_remove_selected_xevent(win, mask) -> num. 
 5829      """ 
 5830   
 5831      _fl_remove_selected_xevent = cfuncproto( 
 5832              load_so_libforms(), "fl_remove_selected_xevent", 
 5833              cty.c_long, [Window, cty.c_long], 
 5834              """)long int fl_remove_selected_xevent(Window win, long int mask) 
 5835              """) 
 5836      ulwin = convert_to_Window(win) 
 5837      lmask = convert_to_long(mask) 
 5838      keep_elem_refs(win, mask, ulwin, lmask) 
 5839      retval = _fl_remove_selected_xevent(ulwin, lmask) 
 5840      return retval 
 5841   
 5842   
 5843  fl_add_selected_xevent = fl_addto_selected_xevent 
 5844   
 5845   
 5846 -def fl_set_idle_delta(delta): 
 5847      """ fl_set_idle_delta(delta) 
 5848      """ 
 5849   
 5850      _fl_set_idle_delta = cfuncproto( 
 5851              load_so_libforms(), "fl_set_idle_delta", 
 5852              None, [cty.c_long], 
 5853              """void fl_set_idle_delta(long int delta) 
 5854              """) 
 5855      ldelta = convert_to_long(delta) 
 5856      keep_elem_refs(delta, ldelta) 
 5857      _fl_set_idle_delta(ldelta) 
 5858   
 5859   
 5860 -def fl_add_event_callback(win, ev, py_AppEventCb, userdata): 
 5861      """ 
 5862          fl_add_event_callback(win, ev, py_AppEventCb, userdata) -> event callback 
 5863   
 5864          Adds an event handler for a window. 
 5865   
 5866          @param win : window id to add event handler to 
 5867          @param ev : event number 
 5868          @param py_AppEventCb : python function for handling event, fn(pXevent, 
 5869             ptr_void) -> num 
 5870          @param userdata : user data argument 
 5871      """ 
 5872   
 5873      _fl_add_event_callback = cfuncproto( 
 5874              load_so_libforms(), "fl_add_event_callback", 
 5875              FL_APPEVENT_CB, [Window, cty.c_int, FL_APPEVENT_CB, cty.c_void_p], 
 5876              """FL_APPEVENT_CB fl_add_event_callback(Window win, int ev, 
 5877                 FL_APPEVENT_CB wincb, void * user_data) 
 5878              """) 
 5879      ulwin = convert_to_Window(win) 
 5880      iev = convert_to_int(ev) 
 5881      c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 
 5882      puserdata = cty.cast(userdata, cty.c_void_p) 
 5883      keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 
 5884      keep_elem_refs(win, ev, userdata, ulwin, iev, puserdata) 
 5885      retval = _fl_add_event_callback(ulwin, iev, c_AppEventCb, puserdata) 
 5886      return retval 
 5887   
 5888   
 5889 -def fl_remove_event_callback(win, ev): 
 5890      """ 
 5891          fl_remove_event_callback(win, ev) 
 5892   
 5893          Removes one or all event callbacks for a window. May be called 
 5894          with for a window for which no event callbacks have been set. 
 5895   
 5896          @param win : window id 
 5897          @param ev : evnet number 
 5898      """ 
 5899   
 5900      _fl_remove_event_callback = cfuncproto( 
 5901              load_so_libforms(), "fl_remove_event_callback", 
 5902              None, [Window, cty.c_int], 
 5903              """void fl_remove_event_callback(Window win, int ev) 
 5904              """) 
 5905      ulwin = convert_to_Window(win) 
 5906      iev = convert_to_int(ev) 
 5907      keep_elem_refs(win, ev, ulwin, iev) 
 5908      _fl_remove_event_callback(ulwin, iev) 
 5909   
 5910   
 5911 -def fl_activate_event_callbacks(win): 
 5912      """ fl_activate_event_callbacks(win) 
 5913   
 5914          @param win : window whose events are referred to 
 5915      """ 
 5916   
 5917      _fl_activate_event_callbacks = cfuncproto( 
 5918              load_so_libforms(), "fl_activate_event_callbacks", 
 5919              None, [Window], 
 5920              """void fl_activate_event_callbacks(Window win) 
 5921              """) 
 5922      ulwin = convert_to_Window(win) 
 5923      keep_elem_refs(win, ulwin) 
 5924      _fl_activate_event_callbacks(ulwin) 
 5925   
 5926   
 5927 -def fl_print_xevent_name(where, pXEvent): 
 5928      """ fl_print_xevent_name(where, pXEvent) -> pXEvent 
 5929      """ 
 5930   
 5931      _fl_print_xevent_name = cfuncproto( 
 5932              load_so_libforms(), "fl_print_xevent_name", 
 5933              cty.POINTER(XEvent), [STRING, cty.POINTER(XEvent)], 
 5934              """XEvent * fl_print_xevent_name(const char * where, 
 5935                 const Xevent * xev) 
 5936              """) 
 5937      swhere = convert_to_string(where) 
 5938      keep_elem_refs(where, pXEvent, swhere) 
 5939      retval = _fl_print_xevent_name(swhere, pXEvent) 
 5940      return retval 
 5941   
 5942   
 5943 -def fl_XFlush(): 
 5944      """ 
 5945           fl_XFlush() 
 5946   
 5947           Convenience replacement for XFlush() 
 5948      """ 
 5949   
 5950      _fl_XFlush = cfuncproto( 
 5951              load_so_libforms(), "fl_XFlush", 
 5952              None, [], 
 5953              """void fl_XFlush(void) 
 5954              """) 
 5955      _fl_XFlush() 
 5956   
 5957   
 5958 -def metakey_down(mask): 
 5959      return (mask & Mod1Mask) 
 5960   
 5961   
 5962 -def shiftkey_down(mask): 
 5963      return (mask & ShiftMask) 
 5964   
 5965   
 5966 -def controlkey_down(mask): 
 5967      return (mask & ControlMask) 
 5968   
 5969   
 5970 -def button_down(mask): 
 5971      if (mask & Button1Mask) or (mask & Button2Mask) or \ 
 5972       (mask & Button3Mask) or (mask & Button4Mask) or \ 
 5973       (mask & Button5Mask): 
 5974          return True 
 5975      else: 
 5976          return False 
 5977   
 5978   
 5979  # Resources 
 5980   
 5981 -def fl_initialize(lsysargv, sysargv, appclass, appopt, nappopt): 
 5982      """ fl_initialize(numargs, args, applclass, apploptions, numapplopts) -> pDisplay 
 5983      """ 
 5984   
 5985      _fl_initialize = cfuncproto( 
 5986              load_so_libforms(), "fl_initialize", 
 5987              cty.POINTER(Display), [cty.POINTER(cty.c_int), 
 5988              cty.POINTER(STRING), STRING, cty.POINTER(XrmOptionDescRec), 
 5989              cty.c_int], 
 5990              """Display * fl_initialize(int * na, char * * arg, 
 5991                 const char * appclass, FL_CMD_OPT * appopt, int nappopt) 
 5992              """) 
 5993      verify_version_compatibility()      # verify if installed XForms 
 5994                                          # is compatible with this one 
 5995      lsysargv = 1 
 5996      cliargs_nr = cty.c_int(lsysargv)               #1 
 5997      cliargs_nr_p = cty.byref(cliargs_nr) 
 5998      argum = "".join(sysargv) 
 5999      scliargs = convert_to_string(argum)            # " " 
 6000      sappclass = convert_to_string(appclass) 
 6001      structopts = cty.POINTER(FL_CMD_OPT)() 
 6002      keep_elem_refs(cliargs_nr_p, scliargs, appclass, sappclass, structopts, 
 6003                     nappopt) 
 6004      retval = _fl_initialize(cliargs_nr_p, scliargs, sappclass, structopts, 
 6005                              nappopt) 
 6006      return retval 
 6007   
 6008   
 6009 -def fl_finish(): 
 6010      """ fl_finish() 
 6011      """ 
 6012   
 6013      _fl_finish = cfuncproto( 
 6014              load_so_libforms(), "fl_finish", 
 6015              None, [], 
 6016              """void fl_finish() 
 6017              """) 
 6018      _fl_finish() 
 6019   
 6020   
 6021 -def fl_get_resource(rname, cname, dtype, defval, val, size): 
 6022      """ fl_get_resource(rname, cname, dtype, defval, val, size) -> string 
 6023      """ 
 6024   
 6025      _fl_get_resource = cfuncproto( 
 6026              load_so_libforms(), "fl_get_resource", 
 6027              STRING, [STRING, STRING, FL_RTYPE, STRING, cty.c_void_p, 
 6028              cty.c_int], 
 6029              """const char * fl_get_resource(const char * rname, 
 6030                 const char * cname, FL_RTYPE dtype, const char * defval, 
 6031                 void * val, int size) 
 6032              """) 
 6033      srname = convert_to_string(rname) 
 6034      scname = convert_to_string(cname) 
 6035      idtype = convert_to_int(dtype) 
 6036      sdefval = convert_to_string(defval) 
 6037      pval = cty.cast(val, cty.c_void_p) 
 6038      isize = convert_to_int(size) 
 6039      keep_elem_refs(rname, cname, dtype, defval, val, size, srname, scname, 
 6040                     idtype, sdefval, pval, isize) 
 6041      retval = _fl_get_resource(srname, scname, idtype, sdefval, pval, isize) 
 6042      return retval 
 6043   
 6044   
 6045 -def fl_set_resource(resstr, val): 
 6046      """ fl_set_resource(resstr, val) 
 6047   
 6048          @param resstr : resource name 
 6049          @param val : new string value for resource 
 6050      """ 
 6051   
 6052      _fl_set_resource = cfuncproto( 
 6053              load_so_libforms(), "fl_set_resource", 
 6054              None, [STRING, STRING], 
 6055              """void fl_set_resource(const char * str, const char * val) 
 6056              """) 
 6057      sresstr = convert_to_string(resstr) 
 6058      sval = convert_to_string(val) 
 6059      keep_elem_refs(resstr, val, sresstr, sval) 
 6060      _fl_set_resource(sresstr, sval) 
 6061   
 6062   
 6063 -def fl_get_app_resources(pResource, n): 
 6064      """ fl_get_app_resources(pResource, n) 
 6065      """ 
 6066   
 6067      _fl_get_app_resources = cfuncproto( 
 6068              load_so_libforms(), "fl_get_app_resources", 
 6069              None, [cty.POINTER(FL_RESOURCE), cty.c_int], 
 6070              """void fl_get_app_resources(FL_RESOURCE * appresource, int n) 
 6071              """) 
 6072      inum = convert_to_int(n) 
 6073      keep_elem_refs(pResource, n, inum) 
 6074      _fl_get_app_resources(pResource, inum) 
 6075   
 6076   
 6077 -def fl_set_graphics_mode(mode, doublebuf): 
 6078      """ fl_set_graphics_mode(mode, doublebuf) 
 6079      """ 
 6080   
 6081      _fl_set_graphics_mode = cfuncproto( 
 6082              load_so_libforms(), "fl_set_graphics_mode", 
 6083              None, [cty.c_int, cty.c_int], 
 6084              """void fl_set_graphics_mode(int mode, int doublebuf) 
 6085              """) 
 6086      imode = convert_to_int(mode) 
 6087      idoublebuf = convert_to_int(doublebuf) 
 6088      keep_elem_refs(mode, doublebuf, imode, idoublebuf) 
 6089      _fl_set_graphics_mode(imode, idoublebuf) 
 6090   
 6091   
 6092 -def fl_set_visualID(idnum): 
 6093      """ fl_set_visualID(idnum) 
 6094      """ 
 6095   
 6096      _fl_set_visualID = cfuncproto( 
 6097              load_so_libforms(), "fl_set_visualID", 
 6098              None, [cty.c_long], 
 6099              """void fl_set_visualID(long int id) 
 6100              """) 
 6101      lidnum = convert_to_long(idnum) 
 6102      keep_elem_refs(idnum, lidnum) 
 6103      _fl_set_visualID(lidnum) 
 6104   
 6105   
 6106 -def fl_keysym_pressed(keysym): 
 6107      """ fl_keysym_pressed(keysym) -> num. 
 6108      """ 
 6109   
 6110      _fl_keysym_pressed = cfuncproto( 
 6111              load_so_libforms(), "fl_keysym_pressed", 
 6112              cty.c_int, [KeySym], 
 6113              """int fl_keysym_pressed(KeySym k) 
 6114              """) 
 6115      ulkeysym = convert_to_ulong(keysym) 
 6116      keep_elem_refs(keysym, ulkeysym) 
 6117      retval = _fl_keysym_pressed(ulkeysym) 
 6118      return retval 
 6119   
 6120   
 6121  fl_keypressed = fl_keysym_pressed 
 6122   
 6123   
 6124  # Program default masks 
 6125   
 6126 -def fl_set_defaults(mask, pIopt): 
 6127      """ fl_set_defaults(mask, pIopt) 
 6128      """ 
 6129   
 6130      _fl_set_defaults = cfuncproto( 
 6131              load_so_libforms(), "fl_set_defaults", 
 6132              None, [cty.c_ulong, cty.POINTER(FL_IOPT)], 
 6133              """void fl_set_defaults(long unsigned int mask, FL_IOPT * cntl): 
 6134              """) 
 6135      ulmask = convert_to_ulong(mask) 
 6136      keep_elem_refs(mask, pIopt, ulmask) 
 6137      _fl_set_defaults(ulmask, pIopt) 
 6138   
 6139   
 6140 -def fl_set_tabstop(s): 
 6141      """ fl_set_tabstop(s) 
 6142      """ 
 6143   
 6144      _fl_set_tabstop = cfuncproto( 
 6145              load_so_libforms(), "fl_set_tabstop", 
 6146              None, [STRING], 
 6147              """void fl_set_tabstop(const char * s) 
 6148              """) 
 6149      ss = convert_to_string(s) 
 6150      keep_elem_refs(s, ss) 
 6151      _fl_set_tabstop(ss) 
 6152   
 6153   
 6154 -def fl_get_defaults(pIopt): 
 6155      """ fl_get_defaults(pIopt) 
 6156      """ 
 6157   
 6158      _fl_get_defaults = cfuncproto( 
 6159              load_so_libforms(), "fl_get_defaults", 
 6160              None, [cty.POINTER(FL_IOPT)], 
 6161              """void fl_get_defaults(FL_IOPT * cntl) 
 6162              """) 
 6163      keep_elem_refs(pIopt) 
 6164      _fl_get_defaults(pIopt) 
 6165   
 6166   
 6167 -def fl_get_visual_depth(): 
 6168      """ fl_get_visual_depth() -> depth num. 
 6169      """ 
 6170   
 6171      _fl_get_visual_depth = cfuncproto( 
 6172              load_so_libforms(), "fl_get_visual_depth", 
 6173              cty.c_int, [], 
 6174              """int fl_get_visual_depth() 
 6175              """) 
 6176      retval = _fl_get_visual_depth() 
 6177      return retval 
 6178   
 6179   
 6180 -def fl_vclass_name(n): 
 6181      """ fl_vclass_name(n) -> name string 
 6182      """ 
 6183   
 6184      _fl_vclass_name = cfuncproto( 
 6185              load_so_libforms(), "fl_vclass_name", 
 6186              STRING, [cty.c_int], 
 6187              """const char * fl_vclass_name(int n) 
 6188              """) 
 6189      inum = convert_to_int(n) 
 6190      keep_elem_refs(n, inum) 
 6191      _fl_vclass_name(inum) 
 6192   
 6193   
 6194 -def fl_vclass_val(val): 
 6195      """ fl_vclass_val(val) -> num. 
 6196      """ 
 6197   
 6198      _fl_vclass_val = cfuncproto( 
 6199              load_so_libforms(), "fl_vclass_val", 
 6200              cty.c_int, [STRING], 
 6201              """int fl_vclass_val(const char * v) 
 6202              """) 
 6203      sval = convert_to_string(val) 
 6204      keep_elem_refs(val, sval) 
 6205      retval = _fl_vclass_val(sval) 
 6206      return retval 
 6207   
 6208   
 6209 -def fl_set_ul_property(prop, thickness): 
 6210      """ fl_set_ul_property(prop, thickness) 
 6211      """ 
 6212   
 6213      _fl_set_ul_property = cfuncproto( 
 6214              load_so_libforms(), "fl_set_ul_property", 
 6215              None, [cty.c_int, cty.c_int], 
 6216              """void fl_set_ul_property(int prop, int thickness) 
 6217              """) 
 6218      iprop = convert_to_int(prop) 
 6219      ithickness = convert_to_int(thickness) 
 6220      keep_elem_refs(prop, thickness, iprop, ithickness) 
 6221      _fl_set_ul_property(iprop, ithickness) 
 6222   
 6223   
 6224 -def fl_set_clipping(x, y, w, h): 
 6225      """ fl_set_clipping(x, y, w, h) 
 6226      """ 
 6227   
 6228      _fl_set_clipping = cfuncproto( 
 6229              load_so_libforms(), "fl_set_clipping", 
 6230              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6231              """void fl_set_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 
 6232                 FL_Coord h) 
 6233              """) 
 6234      ix = convert_to_FL_Coord(x) 
 6235      iy = convert_to_FL_Coord(y) 
 6236      iw = convert_to_FL_Coord(w) 
 6237      ih = convert_to_FL_Coord(h) 
 6238      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 6239      _fl_set_clipping(ix, iy, iw, ih) 
 6240   
 6241   
 6242 -def fl_set_gc_clipping(gc, x, y, w, h): 
 6243      """ fl_set_gc_clipping(gc, x, y, w, h) 
 6244      """ 
 6245   
 6246      _fl_set_gc_clipping = cfuncproto( 
 6247              load_so_libforms(), "fl_set_gc_clipping", 
 6248              None, [GC, FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6249              """void fl_set_gc_clipping(GC gc, FL_Coord x, FL_Coord y, 
 6250                 FL_Coord w, FL_Coord h) 
 6251              """) 
 6252      ix = convert_to_FL_Coord(x) 
 6253      iy = convert_to_FL_Coord(y) 
 6254      iw = convert_to_FL_Coord(w) 
 6255      ih = convert_to_FL_Coord(h) 
 6256      keep_elem_refs(gc, x, y, w, h, ix, iy, iw, ih) 
 6257      _fl_set_gc_clipping(gc, ix, iy, iw, ih) 
 6258   
 6259   
 6260 -def fl_unset_gc_clipping(gc): 
 6261      """ fl_unset_gc_clipping(gc) 
 6262      """ 
 6263   
 6264      _fl_unset_gc_clipping = cfuncproto( 
 6265              load_so_libforms(), "fl_unset_gc_clipping", 
 6266              None, [GC], 
 6267              """void fl_unset_gc_clipping(GC gc) 
 6268              """) 
 6269      keep_elem_refs(gc) 
 6270      _fl_unset_gc_clipping(gc) 
 6271   
 6272   
 6273 -def fl_set_clippings(pRect, n): 
 6274      """ fl_set_clippings(pRect, n) 
 6275      """ 
 6276   
 6277      _fl_set_clippings = cfuncproto( 
 6278              load_so_libforms(), "fl_set_clippings", 
 6279              None, [cty.POINTER(FL_RECT), cty.c_int], 
 6280              """void fl_set_clippings(FL_RECT * xrect, int n) 
 6281              """) 
 6282      inum = convert_to_int(n) 
 6283      keep_elem_refs(pRect, n, inum) 
 6284      _fl_set_clippings(pRect, inum) 
 6285   
 6286   
 6287 -def fl_unset_clipping(): 
 6288      """ fl_unset_clipping() 
 6289      """ 
 6290   
 6291      _fl_unset_clipping = cfuncproto( 
 6292              load_so_libforms(), "fl_unset_clipping", 
 6293              None, [], 
 6294              """void fl_unset_clipping() 
 6295              """) 
 6296      _fl_unset_clipping() 
 6297   
 6298   
 6299 -def fl_set_text_clipping(x, y, w, h): 
 6300      """ fl_set_text_clipping(x, y, w, h) 
 6301      """ 
 6302   
 6303      _fl_set_text_clipping = cfuncproto( 
 6304              load_so_libforms(), "fl_set_text_clipping", 
 6305              None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 
 6306              """void fl_set_text_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 
 6307                 FL_Coord h) 
 6308              """) 
 6309      ix = convert_to_FL_Coord(x) 
 6310      iy = convert_to_FL_Coord(y) 
 6311      iw = convert_to_FL_Coord(w) 
 6312      ih = convert_to_FL_Coord(h) 
 6313      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
 6314      _fl_set_text_clipping(ix, iy, iw, ih) 
 6315   
 6316   
 6317 -def fl_unset_text_clipping(): 
 6318      """ fl_unset_text_clipping() 
 6319      """ 
 6320   
 6321      _fl_unset_text_clipping = cfuncproto( 
 6322              load_so_libforms(), "fl_unset_text_clipping", 
 6323              None, [], 
 6324              """void fl_unset_text_clipping() 
 6325              """) 
 6326      _fl_unset_text_clipping() 
 6327   
 6328   
 6329  # How we pack and unpack colors 
 6330   
 6331 -def FL_PCCLAMP(a): 
 6332      if (a > FL_PCMAX): 
 6333          return FL_PCMAX 
 6334      elif (a < 0): 
 6335          return 0 
 6336      else: 
 6337          return a 
 6338   
 6339   
 6340  # If PCBITS is not 8, we need to apply the RGBmask 
 6341   
 6342 -def FL_GETR(packed): 
 6343      return ((packed >> FL_RSHIFT) & FL_RMASK) 
 6344   
 6345  # maybe unused in python? 
 6346 -def FL_GETG(packed): 
 6347      return ((packed) >> FL_GSHIFT) & FL_PCMAX 
 6348   
 6349  # maybe unused in python? 
 6350 -def FL_GETB(packed): 
 6351      return ((packed) >> FL_BSHIFT) & FL_PCMAX 
 6352   
 6353  # maybe unused in python? 
 6354 -def FL_GETA(packed): 
 6355      return ((packed) >> FL_ASHIFT) & FL_PCMAX 
 6356   
 6357  # maybe unused in python? 
 6358 -def FL_PACK3(r, g, b ): 
 6359      return (r<<FL_RSHIFT) | (g<<FL_GSHIFT) | (b<<FL_BSHIFT) 
 6360   
 6361  # maybe unused in python? 
 6362  FL_PACK = FL_PACK3 
 6363   
 6364  # maybe unused in python? 
 6365 -def FL_PACK4(r, g, b, a): 
 6366      return (FL_PACK3(r, g, b) | (a<<FL_ASHIFT)) 
 6367   
 6368  # maybe unused in python? 
 6369 -def FL_UNPACK(p, r, g, b): 
 6370      r = FL_GETR(p) 
 6371      g = FL_GETG(p) 
 6372      b = FL_GETB(p) 
 6373      return r, g, b 
 6374   
 6375  # maybe unused in python? 
 6376  FL_UNPACK3 = FL_UNPACK 
 6377   
 6378  # maybe unused in python? 
 6379 -def FL_UNPACK4(p, r, g, b, a): 
 6380      r, g, b = FL_UNPACK3(p, r, g, b) 
 6381      a = FL_GETA(p) 
 6382      return r, g, b, a 
 6383   
 6384   
 6385 -def fl_popup_add(win, text): 
 6386      """ fl_popup_add(win, text) -> pPopup 
 6387      """ 
 6388   
 6389      _fl_popup_add = cfuncproto( 
 6390              load_so_libforms(), "fl_popup_add", 
 6391              cty.POINTER(FL_POPUP), [Window, STRING], 
 6392              """FL_POPUP * fl_popup_add(Window p1, const char * p2) 
 6393              """) 
 6394      ulwin = convert_to_Window(win) 
 6395      stext = convert_to_string(text) 
 6396      keep_elem_refs(win, text, ulwin, stext) 
 6397      retval = _fl_popup_add(ulwin, stext) 
 6398      return retval 
 6399   
 6400   
 6401 -def fl_popup_add_entries(pPopup, entrytxt): 
 6402      """ fl_popup_add_entries(pPopup, entrytxt) -> pPopupEntry 
 6403      """ 
 6404   
 6405      _fl_popup_add_entries = cfuncproto( 
 6406              load_so_libforms(), "fl_popup_add_entries", 
 6407              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 6408              """FL_POPUP_ENTRY * fl_popup_add_entries(FL_POPUP * p1, 
 6409                 const char * p2) 
 6410              """) 
 6411      sentrytxt = convert_to_string(entrytxt) 
 6412      keep_elem_refs(pPopup, entrytxt, sentrytxt) 
 6413      retval = _fl_popup_add_entries(pPopup, sentrytxt) 
 6414      return retval 
 6415   
 6416   
 6417 -def fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt): 
 6418      """ fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt) -> pPopupEntry 
 6419      """ 
 6420   
 6421      _fl_popup_insert_entries = cfuncproto( 
 6422              load_so_libforms(), "fl_popup_insert_entries", 
 6423              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), 
 6424              cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6425              """FL_POPUP_ENTRY * fl_popup_insert_entries(FL_POPUP * p1, 
 6426                 FL_POPUP_ENTRY * p2, const char * p3) 
 6427              """) 
 6428      sentrytxt = convert_to_string(entrytxt) 
 6429      keep_elem_refs(pPopup, pPopupEntry, entrytxt, sentrytxt) 
 6430      retval = _fl_popup_insert_entries(pPopup, pPopupEntry, sentrytxt) 
 6431      return retval 
 6432   
 6433   
 6434 -def fl_popup_create(win, text, pPopupItem): 
 6435      """ fl_popup_create(win, text, pPopupItem) -> pPopup 
 6436      """ 
 6437   
 6438      _fl_popup_create = cfuncproto( 
 6439              load_so_libforms(), "fl_popup_create", 
 6440                  cty.POINTER(FL_POPUP), [Window, STRING, 
 6441                  cty.POINTER(FL_POPUP_ITEM)], 
 6442              """FL_POPUP * fl_popup_create(Window p1, const char * p2, 
 6443                 FL_POPUP_ITEM * p3) 
 6444              """) 
 6445      ulwin = convert_to_Window(win) 
 6446      stext = convert_to_string(text) 
 6447      keep_elem_refs(win, text, pPopupItem, ulwin, stext) 
 6448      retval = _fl_popup_create(ulwin, stext, pPopupItem) 
 6449      return retval 
 6450   
 6451   
 6452 -def fl_popup_delete(pPopup): 
 6453      """ fl_popup_delete(pPopup) -> num. 
 6454      """ 
 6455   
 6456      _fl_popup_delete = cfuncproto( 
 6457              load_so_libforms(), "fl_popup_delete", 
 6458              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6459              """int fl_popup_delete(FL_POPUP * p1) 
 6460              """) 
 6461      keep_elem_refs(pPopup) 
 6462      retval = _fl_popup_delete(pPopup) 
 6463      return retval 
 6464   
 6465   
 6466 -def fl_popup_entry_delete(pPopupEntry): 
 6467      """ fl_popup_entry_delete(pPopupEntry) -> num. 
 6468      """ 
 6469   
 6470      _fl_popup_entry_delete = cfuncproto( 
 6471              load_so_libforms(), "fl_popup_entry_delete", 
 6472              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 
 6473              """int fl_popup_entry_delete(FL_POPUP_ENTRY * p1) 
 6474              """) 
 6475      keep_elem_refs(pPopupEntry) 
 6476      retval = _fl_popup_entry_delete(pPopupEntry) 
 6477      return retval 
 6478   
 6479   
 6480 -def fl_popup_do(pPopup): 
 6481      """ fl_popup_do(pPopup) -> pPopupReturn 
 6482      """ 
 6483   
 6484      _fl_popup_do = cfuncproto( 
 6485              load_so_libforms(), "fl_popup_do", 
 6486              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_POPUP)], 
 6487              """FL_POPUP_RETURN * fl_popup_do(FL_POPUP * p1) 
 6488              """) 
 6489      keep_elem_refs(pPopup) 
 6490      retval = _fl_popup_do(pPopup) 
 6491      return retval 
 6492   
 6493   
 6494 -def fl_popup_set_position(pPopup, x, y): 
 6495      """ 
 6496          fl_popup_set_position(pPopup, x, y) 
 6497   
 6498          Sets position where the popup is supposed to appear (if never called 
 6499          the popup appears at the mouse position) 
 6500   
 6501          @param pPopup : pointer to Popup 
 6502          @param x : horizontal position (upper-left corner) 
 6503          @param y : vertical position (upper-left corner) 
 6504      """ 
 6505   
 6506      _fl_popup_set_position = cfuncproto( 
 6507              load_so_libforms(), "fl_popup_set_position", 
 6508              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6509              """void fl_popup_set_position(FL_POPUP * p1, int p2, int p3) 
 6510              """) 
 6511      ix = convert_to_int(x) 
 6512      iy = convert_to_int(y) 
 6513      keep_elem_refs(pPopup, x, y, ix, iy) 
 6514      _fl_popup_set_position(pPopup, ix, iy) 
 6515   
 6516   
 6517 -def fl_popup_get_policy(pPopup): 
 6518      """ 
 6519          fl_popup_get_policy(pPopup) -> num. 
 6520      """ 
 6521   
 6522      _fl_popup_get_policy = cfuncproto( 
 6523              load_so_libforms(), "fl_popup_get_policy", 
 6524              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6525              """int fl_popup_get_policy(FL_POPUP * p1) 
 6526              """) 
 6527      keep_elem_refs(pPopup) 
 6528      retval = _fl_popup_get_policy(pPopup) 
 6529      return retval 
 6530   
 6531   
 6532 -def fl_popup_set_policy(pPopup, policy): 
 6533      """ 
 6534          fl_popup_set_policy(pPopup, policy) -> num. 
 6535   
 6536          Sets policy of handling the popup (i.e. does it get closed when the 
 6537          user releases the mouse button outside an active entry or not?) 
 6538   
 6539          @param pPopup : pointer to Popup 
 6540          @param policy : policy to be set 
 6541      """ 
 6542   
 6543      _fl_popup_set_policy = cfuncproto( 
 6544              load_so_libforms(), "fl_popup_set_policy", 
 6545              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 6546              """int fl_popup_set_policy(FL_POPUP * p1, int p2) 
 6547              """) 
 6548      ipolicy = convert_to_int(policy) 
 6549      keep_elem_refs(pPopup, policy, ipolicy) 
 6550      retval = _fl_popup_set_policy(pPopup, ipolicy) 
 6551      return retval 
 6552   
 6553   
 6554  # already defined in xfdata 
 6555  #FL_POPUP_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_POPUP_RETURN)) 
 6556   
 6557 -def fl_popup_set_callback(pPopup, py_PopupCb): 
 6558      """ 
 6559          fl_popup_set_callback(pPopup, py_PopupCb) -> popup callback func. 
 6560      """ 
 6561   
 6562      _fl_popup_set_callback = cfuncproto( 
 6563              load_so_libforms(), "fl_popup_set_callback", 
 6564              FL_POPUP_CB, [cty.POINTER(FL_POPUP), FL_POPUP_CB], 
 6565              """FL_POPUP_CB fl_popup_set_callback(FL_POPUP * p1, 
 6566                 FL_POPUP_CB p2) 
 6567              """) 
 6568      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6569      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6570      keep_elem_refs(pPopup) 
 6571      retval = _fl_popup_set_callback(pPopup, c_PopupCb) 
 6572      return retval 
 6573   
 6574   
 6575  #def fl_popup_get_title_font(pPopup, style, size)       *API change* 
 6576 -def fl_popup_get_title_font(pPopup): 
 6577      """ 
 6578          fl_popup_get_title_font(pPopup) -> style, size 
 6579      """ 
 6580   
 6581      _fl_popup_get_title_font = cfuncproto( 
 6582              load_so_libforms(), "fl_popup_get_title_font", 
 6583              None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 
 6584              cty.POINTER(cty.c_int)], 
 6585              """void fl_popup_get_title_font(FL_POPUP * p1, int * p2, 
 6586                 int * p3) 
 6587              """) 
 6588      style, pstyle = make_int_and_pointer() 
 6589      size, psize = make_int_and_pointer() 
 6590      keep_elem_refs(pPopup, style, size, pstyle, psize) 
 6591      _fl_popup_get_title_font(pPopup, pstyle, psize) 
 6592      return style, size 
 6593   
 6594   
 6595 -def fl_popup_set_title_font(pPopup, style, size): 
 6596      """ 
 6597          fl_popup_set_title_font(pPopup, style, size) 
 6598      """ 
 6599   
 6600      _fl_popup_set_title_font = cfuncproto( 
 6601              load_so_libforms(), "fl_popup_set_title_font", 
 6602              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6603              """void fl_popup_set_title_font(FL_POPUP * p1, int p2, int p3) 
 6604              """) 
 6605      istyle = convert_to_int(style) 
 6606      isize = convert_to_int(size) 
 6607      keep_elem_refs(pPopup, style, size, istyle, isize) 
 6608      _fl_popup_set_title_font(pPopup, istyle, isize) 
 6609   
 6610   
 6611  #def fl_popup_entry_get_font(pPopup, style, size)       *API change* 
 6612 -def fl_popup_entry_get_font(pPopup): 
 6613      """ 
 6614          fl_popup_entry_get_font(pPopup) -> style, size 
 6615      """ 
 6616   
 6617      _fl_popup_entry_get_font = cfuncproto( 
 6618              load_so_libforms(), "fl_popup_entry_get_font", 
 6619              None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 
 6620              cty.POINTER(cty.c_int)], 
 6621              """void fl_popup_entry_get_font(FL_POPUP * p1, int * p2, int * p3) 
 6622              """) 
 6623      style, pstyle = make_int_and_pointer() 
 6624      size, psize = make_int_and_pointer() 
 6625      keep_elem_refs(pPopup, style, size, pstyle, psize) 
 6626      _fl_popup_entry_get_font(pPopup, pstyle, psize) 
 6627      return style, size 
 6628   
 6629   
 6630 -def fl_popup_entry_set_font(pPopup, style, size): 
 6631      """ 
 6632          fl_popup_entry_set_font(pPopup, style, size) 
 6633   
 6634          Sets the font of a popup entry. 
 6635   
 6636          @param pPopup : pointer to Popup 
 6637          @param style : style of the popup entry 
 6638          @param size : size of the popup entry 
 6639      """ 
 6640   
 6641      _fl_popup_entry_set_font = cfuncproto( 
 6642              load_so_libforms(), "fl_popup_entry_set_font", 
 6643              None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 
 6644              """void fl_popup_entry_set_font(FL_POPUP * p1, int p2, int p3) 
 6645              """) 
 6646      istyle = convert_to_int(style) 
 6647      isize = convert_to_int(size) 
 6648      keep_elem_refs(pPopup, style, size, istyle, isize) 
 6649      _fl_popup_entry_set_font(pPopup, istyle, isize) 
 6650   
 6651   
 6652 -def fl_popup_get_bw(pPopup): 
 6653      """ 
 6654          fl_popup_get_bw(pPopup) -> borderwidth 
 6655   
 6656          Returns the border width of a popup. 
 6657   
 6658          @param pPopup : pointer to popup 
 6659      """ 
 6660   
 6661      _fl_popup_get_bw = cfuncproto( 
 6662              load_so_libforms(), "fl_popup_get_bw", 
 6663              cty.c_int, [cty.POINTER(FL_POPUP)], 
 6664              """int fl_popup_get_bw(FL_POPUP * p1) 
 6665              """) 
 6666      keep_elem_refs(pPopup) 
 6667      retval = _fl_popup_get_bw(pPopup) 
 6668      return retval 
 6669   
 6670   
 6671 -def fl_popup_set_bw(pPopup, bw): 
 6672      """ 
 6673          fl_popup_set_bw(pPopup, bw) -> num. 
 6674   
 6675          Sets the border width of a popup. 
 6676   
 6677          @param pPopup : pointer to popup 
 6678          @param bw : border width value to be set 
 6679      """ 
 6680   
 6681      _fl_popup_set_bw = cfuncproto( 
 6682              load_so_libforms(), "fl_popup_set_bw", 
 6683              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 6684              """int fl_popup_set_bw(FL_POPUP * p1, int p2) 
 6685              """) 
 6686      ibw = convert_to_int(bw) 
 6687      keep_elem_refs(pPopup, bw, ibw) 
 6688      retval = _fl_popup_set_bw(pPopup, ibw) 
 6689      return retval 
 6690   
 6691   
 6692 -def fl_popup_get_color(pPopup, p2): 
 6693      """ 
 6694          fl_popup_get_color(pPopup, p2) -> color 
 6695      """ 
 6696   
 6697      _fl_popup_get_color = cfuncproto( 
 6698              load_so_libforms(), "fl_popup_get_color", 
 6699              FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int], 
 6700              """FL_COLOR fl_popup_get_color(FL_POPUP * p1, int p2) 
 6701              """) 
 6702      ip2 = convert_to_int(p2) 
 6703      keep_elem_refs(pPopup, p2, ip2) 
 6704      retval = _fl_popup_get_color(pPopup, ip2) 
 6705      return retval 
 6706   
 6707   
 6708 -def fl_popup_set_color(pPopup, p2, colr): 
 6709      """ fl_popup_set_color(pPopup, p2, colr) -> color 
 6710      """ 
 6711   
 6712      _fl_popup_set_color = cfuncproto( 
 6713              load_so_libforms(), "fl_popup_set_color", 
 6714              FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int, FL_COLOR], 
 6715              """FL_COLOR fl_popup_set_color(FL_POPUP * p1, int p2, FL_COLOR p3) 
 6716              """) 
 6717      check_admitted_listvalues(colr, COLOR_list) 
 6718      ip2 = convert_to_int(p2) 
 6719      ulcolr = convert_to_FL_COLOR(colr) 
 6720      keep_elem_refs(pPopup, p2, colr, ip2, ulcolr) 
 6721      retval = _fl_popup_set_color(pPopup, ip2, ulcolr) 
 6722      return retval 
 6723   
 6724   
 6725 -def fl_popup_set_cursor(pPopup, cursnum): 
 6726      """ 
 6727          fl_popup_set_cursor(pPopup, cursnum) 
 6728      """ 
 6729   
 6730      _fl_popup_set_cursor = cfuncproto( 
 6731              load_so_libforms(), "fl_popup_set_cursor", 
 6732              None, [cty.POINTER(FL_POPUP), cty.c_int], 
 6733              """void fl_popup_set_cursor(FL_POPUP * p1, int p2) 
 6734              """) 
 6735      icursnum = convert_to_int(cursnum) 
 6736      keep_elem_refs(pPopup, cursnum, icursnum) 
 6737      _fl_popup_set_cursor(pPopup, icursnum) 
 6738   
 6739   
 6740 -def fl_popup_get_title(pPopup): 
 6741      """ 
 6742          fl_popup_get_title(pPopup) -> title string 
 6743   
 6744          Returns the title of a popup. 
 6745   
 6746          @param pPopup : pointer to popup 
 6747      """ 
 6748   
 6749      _fl_popup_get_title = cfuncproto( 
 6750              load_so_libforms(), "fl_popup_get_title", 
 6751              STRING, [cty.POINTER(FL_POPUP)], 
 6752              """const char * fl_popup_get_title(FL_POPUP * p1) 
 6753              """) 
 6754      keep_elem_refs(pPopup) 
 6755      retval = _fl_popup_get_title(pPopup) 
 6756      return retval 
 6757   
 6758   
 6759 -def fl_popup_set_title(pPopup, title): 
 6760      """ fl_popup_set_title(pPopup, title) -> popup 
 6761   
 6762          Sets the title of a popup. 
 6763   
 6764          @param pPopup : pointer to popup 
 6765          @param title : title of the popup 
 6766      """ 
 6767   
 6768      _fl_popup_set_title = cfuncproto( 
 6769              load_so_libforms(), "fl_popup_set_title", 
 6770              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP), STRING], 
 6771              """FL_POPUP * fl_popup_set_title(FL_POPUP * p1, const char * p2) 
 6772              """) 
 6773      stitle = convert_to_string(title) 
 6774      keep_elem_refs(pPopup, title, stitle) 
 6775      retval = _fl_popup_set_title(pPopup, stitle) 
 6776      return retval 
 6777   
 6778   
 6779 -def fl_popup_entry_set_callback(pPopupEntry, py_PopupCb): 
 6780      """ fl_popup_entry_set_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6781      """ 
 6782   
 6783      _fl_popup_entry_set_callback = cfuncproto( 
 6784              load_so_libforms(), "fl_popup_entry_set_callback", 
 6785              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6786              """FL_POPUP_CB fl_popup_entry_set_callback(FL_POPUP_ENTRY * p1, 
 6787                 FL_POPUP_CB p2) 
 6788              """) 
 6789      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6790      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6791      keep_elem_refs(pPopupEntry) 
 6792      retval = _fl_popup_entry_set_callback(pPopupEntry, c_PopupCb) 
 6793      return retval 
 6794   
 6795   
 6796 -def fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb): 
 6797      """ fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6798      """ 
 6799   
 6800      _fl_popup_entry_set_enter_callback = cfuncproto( 
 6801              load_so_libforms(), "fl_popup_entry_set_enter_callback", 
 6802              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6803              """FL_POPUP_CB fl_popup_entry_set_enter_callback( 
 6804                 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 
 6805              """) 
 6806      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6807      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6808      keep_elem_refs(pPopupEntry) 
 6809      retval = _fl_popup_entry_set_enter_callback(pPopupEntry, c_PopupCb) 
 6810      return retval 
 6811   
 6812   
 6813 -def fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb): 
 6814      """ fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb) -> popup_callback 
 6815      """ 
 6816   
 6817      _fl_popup_entry_set_leave_callback = cfuncproto( 
 6818              load_so_libforms(), "fl_popup_entry_set_leave_callback", 
 6819              FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 
 6820              """FL_POPUP_CB fl_popup_entry_set_leave_callback( 
 6821                 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 
 6822              """) 
 6823      c_PopupCb = FL_POPUP_CB(py_PopupCb) 
 6824      keep_cfunc_refs(c_PopupCb, py_PopupCb) 
 6825      keep_elem_refs(pPopupEntry) 
 6826      retval = _fl_popup_entry_set_leave_callback(pPopupEntry, c_PopupCb) 
 6827      return retval 
 6828   
 6829   
 6830 -def fl_popup_entry_get_state(pPopupEntry): 
 6831      """ fl_popup_entry_get_state(pPopupEntry) -> state num. 
 6832      """ 
 6833   
 6834      _fl_popup_entry_get_state = cfuncproto( 
 6835              load_so_libforms(), "fl_popup_entry_get_state", 
 6836              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY)], 
 6837              """unsigned int fl_popup_entry_get_state(FL_POPUP_ENTRY * p1) 
 6838              """) 
 6839      keep_elem_refs(pPopupEntry) 
 6840      retval = _fl_popup_entry_get_state(pPopupEntry) 
 6841      return retval 
 6842   
 6843   
 6844 -def fl_popup_entry_set_state(pPopupEntry, state): 
 6845      """ fl_popup_entry_set_state(pPopupEntry, state) -> state num. 
 6846      """ 
 6847   
 6848      _fl_popup_entry_set_state = cfuncproto( 
 6849              load_so_libforms(), "fl_popup_entry_set_state", 
 6850              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6851              """unsigned int fl_popup_entry_set_state(FL_POPUP_ENTRY * p1, 
 6852                 unsigned int p2) 
 6853              """) 
 6854      uistate = convert_to_uint(state) 
 6855      keep_elem_refs(pPopupEntry, state, uistate) 
 6856      retval = _fl_popup_entry_set_state(pPopupEntry, uistate) 
 6857      return retval 
 6858   
 6859   
 6860 -def fl_popup_entry_clear_state(pPopupEntry, state): 
 6861      """ fl_popup_entry_clear_state(pPopupEntry, state) -> state num. 
 6862      """ 
 6863   
 6864      _fl_popup_entry_clear_state = cfuncproto( 
 6865              load_so_libforms(), "fl_popup_entry_clear_state", 
 6866              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6867              """unsigned int fl_popup_entry_clear_state(FL_POPUP_ENTRY * p1, 
 6868                 unsigned int p2) 
 6869              """) 
 6870      uistate = convert_to_uint(state) 
 6871      keep_elem_refs(pPopupEntry, state, uistate) 
 6872      retval = _fl_popup_entry_clear_state(pPopupEntry, uistate) 
 6873      return retval 
 6874   
 6875   
 6876 -def fl_popup_entry_raise_state(pPopupEntry, state): 
 6877      """ fl_popup_entry_raise_state(pPopupEntry, state) -> state num. 
 6878      """ 
 6879   
 6880      _fl_popup_entry_raise_state = cfuncproto( 
 6881              load_so_libforms(), "fl_popup_entry_raise_state", 
 6882              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6883              """unsigned int fl_popup_entry_raise_state(FL_POPUP_ENTRY * p1, 
 6884                 unsigned int p2) 
 6885              """) 
 6886      uistate = convert_to_uint(state) 
 6887      keep_elem_refs(pPopupEntry, state, uistate) 
 6888      retval = _fl_popup_entry_raise_state(pPopupEntry, uistate) 
 6889      return retval 
 6890   
 6891   
 6892 -def fl_popup_entry_toggle_state(pPopupEntry, state): 
 6893      """ fl_popup_entry_toggle_state(pPopupEntry, state) -> num. 
 6894      """ 
 6895   
 6896      _fl_popup_entry_toggle_state = cfuncproto( 
 6897              load_so_libforms(), "fl_popup_entry_toggle_state", 
 6898              cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 
 6899              """unsigned int fl_popup_entry_toggle_state(FL_POPUP_ENTRY * p1, 
 6900                 unsigned int p2) 
 6901              """) 
 6902      uistate = convert_to_uint(state) 
 6903      keep_elem_refs(pPopupEntry, state, uistate) 
 6904      retval = _fl_popup_entry_toggle_state(pPopupEntry, uistate) 
 6905      return retval 
 6906   
 6907   
 6908 -def fl_popup_entry_set_text(pPopupEntry, text): 
 6909      """ fl_popup_entry_set_text(p1, txtstr) -> num. 
 6910      """ 
 6911   
 6912      _fl_popup_entry_set_text = cfuncproto( 
 6913              load_so_libforms(), "fl_popup_entry_set_text", 
 6914              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6915              """int fl_popup_entry_set_text(FL_POPUP_ENTRY * p1, 
 6916                 const char * p2) 
 6917              """) 
 6918      stext = convert_to_string(text) 
 6919      keep_elem_refs(pPopupEntry, text, stext) 
 6920      retval = _fl_popup_entry_set_text(pPopupEntry, stext) 
 6921      return retval 
 6922   
 6923   
 6924 -def fl_popup_entry_set_shortcut(pPopupEntry, textsc): 
 6925      """ fl_popup_entry_set_shortcut(pPopupEntry, textsc) 
 6926      """ 
 6927   
 6928      _fl_popup_entry_set_shortcut = cfuncproto( 
 6929              load_so_libforms(), "fl_popup_entry_set_shortcut", 
 6930              None, [cty.POINTER(FL_POPUP_ENTRY), STRING], 
 6931              """void fl_popup_entry_set_shortcut(FL_POPUP_ENTRY * p1, 
 6932                 const char * p2) 
 6933              """) 
 6934      stextsc = convert_to_string(textsc) 
 6935      keep_elem_refs(pPopupEntry, textsc, stextsc) 
 6936      _fl_popup_entry_set_shortcut(pPopupEntry, stextsc) 
 6937   
 6938   
 6939 -def fl_popup_entry_set_value(pPopupEntry, val): 
 6940      """ fl_popup_entry_set_value(pPopupEntry, p2) -> num. 
 6941      """ 
 6942   
 6943      _fl_popup_entry_set_value = cfuncproto( 
 6944              load_so_libforms(), "fl_popup_entry_set_value", 
 6945              cty.c_long, [cty.POINTER(FL_POPUP_ENTRY), cty.c_long], 
 6946              """long int fl_popup_entry_set_value(FL_POPUP_ENTRY * p1, 
 6947                 long int p2) 
 6948              """) 
 6949      lval = convert_to_long(val) 
 6950      keep_elem_refs(pPopupEntry, val, lval) 
 6951      retval = _fl_popup_entry_set_value(pPopupEntry, lval) 
 6952      return retval 
 6953   
 6954   
 6955 -def fl_popup_entry_set_user_data(pPopupEntry, data): 
 6956      """ fl_popup_entry_set_user_data(pPopupEntry, data) -> ?? 
 6957      """ 
 6958   
 6959      _fl_popup_entry_set_user_data = cfuncproto( 
 6960              load_so_libforms(), "fl_popup_entry_set_user_data", 
 6961              cty.c_void_p, [cty.POINTER(FL_POPUP_ENTRY), cty.c_void_p], 
 6962              """void * fl_popup_entry_set_user_data(FL_POPUP_ENTRY * p1, 
 6963                 void * p2) 
 6964              """) 
 6965      pdata = cty.cast(data, cty.c_void_p) 
 6966      keep_elem_refs(pPopupEntry, data, pdata) 
 6967      retval = _fl_popup_entry_set_user_data(pPopupEntry, pdata) 
 6968      return retval 
 6969   
 6970   
 6971 -def fl_popup_entry_get_by_position(pPopup, numpos): 
 6972      """ fl_popup_entry_get_by_position(pPopup, numpos) -> pPopupEntry 
 6973      """ 
 6974   
 6975      _fl_popup_entry_get_by_position = cfuncproto( 
 6976              load_so_libforms(), "fl_popup_entry_get_by_position", 
 6977              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_int], 
 6978              """FL_POPUP_ENTRY * fl_popup_entry_get_by_position(FL_POPUP * p1, 
 6979                 int p2) 
 6980              """) 
 6981      inumpos = convert_to_int(numpos) 
 6982      keep_elem_refs(pPopup, numpos, inumpos) 
 6983      retval = _fl_popup_entry_get_by_position(pPopup, inumpos) 
 6984      return retval 
 6985   
 6986   
 6987 -def fl_popup_entry_get_by_value(pPopup, val): 
 6988      """ fl_popup_entry_get_by_value(pPopup, val) -> pPopupEntry 
 6989      """ 
 6990   
 6991      _fl_popup_entry_get_by_value = cfuncproto( 
 6992              load_so_libforms(), "fl_popup_entry_get_by_value", 
 6993              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_long], 
 6994              """FL_POPUP_ENTRY * fl_popup_entry_get_by_value(FL_POPUP * p1, 
 6995                 long int p2) 
 6996              """) 
 6997      lval = convert_to_long(val) 
 6998      keep_elem_refs(pPopup, val, lval) 
 6999      retval = _fl_popup_entry_get_by_value(pPopup, lval) 
 7000      return retval 
 7001   
 7002   
 7003 -def fl_popup_entry_get_by_user_data(pPopup, userdata): 
 7004      """ fl_popup_entry_get_by_user_data(pPopup, userdata) -> pPopupEntry 
 7005      """ 
 7006   
 7007      _fl_popup_entry_get_by_user_data = cfuncproto( 
 7008              load_so_libforms(), "fl_popup_entry_get_by_user_data", 
 7009              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_void_p], 
 7010              """FL_POPUP_ENTRY * fl_popup_entry_get_by_user_data(FL_POPUP * p1, 
 7011                 void * p2) 
 7012              """) 
 7013      puserdata = cty.cast(userdata, cty.c_void_p) 
 7014      keep_elem_refs(pPopup, userdata, puserdata) 
 7015      retval = _fl_popup_entry_get_by_user_data(pPopup, puserdata) 
 7016      return retval 
 7017   
 7018   
 7019 -def fl_popup_entry_get_by_text(pPopup, text): 
 7020      """ fl_popup_entry_get_by_text(pPopup, text) -> pPopupEntry 
 7021      """ 
 7022   
 7023      _fl_popup_entry_get_by_text = cfuncproto( 
 7024              load_so_libforms(), "fl_popup_entry_get_by_text", 
 7025              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 7026              """FL_POPUP_ENTRY * fl_popup_entry_get_by_text(FL_POPUP * p1, 
 7027                 const char * p2) 
 7028              """) 
 7029      stext = convert_to_string(text) 
 7030      keep_elem_refs(pPopup, text, stext) 
 7031      retval = _fl_popup_entry_get_by_text(pPopup, stext) 
 7032      return retval 
 7033   
 7034   
 7035 -def fl_popup_entry_get_by_label(pPopup, label): 
 7036      """ fl_popup_entry_get_by_label(pPopup, label) -> pPopupEntry 
 7037      """ 
 7038   
 7039      _fl_popup_entry_get_by_label = cfuncproto( 
 7040              load_so_libforms(), "fl_popup_entry_get_by_label", 
 7041              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 
 7042              """FL_POPUP_ENTRY * fl_popup_entry_get_by_label(FL_POPUP * p1, 
 7043                 const char * p2) 
 7044              """) 
 7045      slabel = convert_to_string(label) 
 7046      keep_elem_refs(pPopup, label, slabel) 
 7047      retval = _fl_popup_entry_get_by_label(pPopup, slabel) 
 7048      return retval 
 7049   
 7050   
 7051 -def fl_popup_entry_get_group(pPopupEntry): 
 7052      """ fl_popup_entry_get_group(pPopupEntry) -> num. 
 7053      """ 
 7054   
 7055      _fl_popup_entry_get_group = cfuncproto( 
 7056              load_so_libforms(), "fl_popup_entry_get_group", 
 7057              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 
 7058              """int fl_popup_entry_get_group(FL_POPUP_ENTRY * p1) 
 7059              """) 
 7060      keep_elem_refs(pPopupEntry) 
 7061      retval = _fl_popup_entry_get_group(pPopupEntry) 
 7062      return retval 
 7063   
 7064   
 7065 -def fl_popup_entry_set_group(pPopupEntry, num): 
 7066      """ fl_popup_entry_set_group(pPopupEntry, num) -> num. 
 7067      """ 
 7068   
 7069      _fl_popup_entry_set_group = cfuncproto( 
 7070              load_so_libforms(), "fl_popup_entry_set_group", 
 7071              cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), cty.c_int], 
 7072              """int fl_popup_entry_set_group(FL_POPUP_ENTRY * p1, int p2) 
 7073              """) 
 7074      inum = convert_to_int(num) 
 7075      keep_elem_refs(pPopupEntry, num, inum) 
 7076      retval = _fl_popup_entry_set_group(pPopupEntry, inum) 
 7077      return retval 
 7078   
 7079   
 7080 -def fl_popup_entry_get_subpopup(pPopupEntry): 
 7081      """ fl_popup_entry_get_subpopup(pPopupEntry) -> pPopup 
 7082      """ 
 7083   
 7084      _fl_popup_entry_get_subpopup = cfuncproto( 
 7085              load_so_libforms(), "fl_popup_entry_get_subpopup", 
 7086              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY)], 
 7087              """FL_POPUP * fl_popup_entry_get_subpopup(FL_POPUP_ENTRY * p1) 
 7088              """) 
 7089      keep_elem_refs(pPopupEntry) 
 7090      retval = _fl_popup_entry_get_subpopup(pPopupEntry) 
 7091      return retval 
 7092   
 7093   
 7094 -def fl_popup_entry_set_subpopup(pPopupEntry, pPopup): 
 7095      """ fl_popup_entry_set_subpopup(pPopupEntry, pPopup) -> pPopup 
 7096      """ 
 7097   
 7098      _fl_popup_entry_set_subpopup = cfuncproto( 
 7099              load_so_libforms(), "fl_popup_entry_set_subpopup", 
 7100              cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY), 
 7101              cty.POINTER(FL_POPUP)], 
 7102              """FL_POPUP * fl_popup_entry_set_subpopup(FL_POPUP_ENTRY * p1, 
 7103                 FL_POPUP * p2) 
 7104              """) 
 7105      keep_elem_refs(pPopupEntry, pPopup) 
 7106      retval = _fl_popup_entry_set_subpopup(pPopupEntry, pPopup) 
 7107      return retval 
 7108   
 7109   
 7110  #def fl_popup_get_size(pPopup, w, h)       *API change* 
 7111 -def fl_popup_get_size(pPopup): 
 7112      """ fl_popup_get_size(pPopup) -> size num., width, height 
 7113      """ 
 7114   
 7115      _fl_popup_get_size = cfuncproto( 
 7116              load_so_libforms(), "fl_popup_get_size", 
 7117              cty.c_int, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_uint), 
 7118              cty.POINTER(cty.c_uint)], 
 7119              """int fl_popup_get_size(FL_POPUP * p1, unsigned int * p2, 
 7120                 unsigned int * p3) 
 7121              """) 
 7122      w, pw = make_uint_and_pointer() 
 7123      h, ph = make_uint_and_pointer() 
 7124      keep_elem_refs(pPopup, w, h, pw, ph) 
 7125      retval = _fl_popup_get_size(pPopup, pw, ph) 
 7126      return retval, w, h 
 7127   
 7128   
 7129 -def fl_popup_get_min_width(pPopup): 
 7130      """ fl_popup_get_min_width(pPopup) -> width num. 
 7131      """ 
 7132   
 7133      _fl_popup_get_min_width = cfuncproto( 
 7134              load_so_libforms(), "fl_popup_get_min_width", 
 7135              cty.c_int, [cty.POINTER(FL_POPUP)], 
 7136              """int fl_popup_get_min_width(FL_POPUP * p1) 
 7137              """) 
 7138      keep_elem_refs(pPopup) 
 7139      retval = _fl_popup_get_min_width(pPopup) 
 7140      return retval 
 7141   
 7142   
 7143 -def fl_popup_set_min_width(pPopup, minwidth): 
 7144      """ fl_popup_set_min_width(pPopup, minwidth) -> width num. 
 7145      """ 
 7146   
 7147      _fl_popup_set_min_width = cfuncproto( 
 7148              load_so_libforms(), "fl_popup_set_min_width", 
 7149              cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 
 7150              """int fl_popup_set_min_width(FL_POPUP * p1, int p2) 
 7151              """) 
 7152      iminwidth = convert_to_int(minwidth) 
 7153      keep_elem_refs(pPopup, minwidth, iminwidth) 
 7154      retval = _fl_popup_set_min_width(pPopup, iminwidth) 
 7155      return retval 
 7156   
 7157   
 7158   
 7159  ####################### 
 7160  # forms.h (bitmap.h) 
 7161  # Object Class: Bitmap 
 7162  ####################### 
 7163   
 7164   
 7165  # Routines 
 7166   
 7167 -def fl_create_bitmap(bitmaptype, x, y, w, h, label): 
 7168      """ 
 7169          fl_create_bitmap(bitmaptype, x, y, w, h, label) -> pObject 
 7170   
 7171          Creates a bitmap object. 
 7172   
 7173          @param bitmaptype : type of bitmap to create 
 7174          @param x : horizontal position of bitmap (upper-left corner) 
 7175          @param y : vertical position of bitmap (upper-left corner) 
 7176          @param w : width of bitmap in pixels 
 7177          @param h : height of bitmap in pixels 
 7178          @param label : text label of bitmap 
 7179      """ 
 7180   
 7181      _fl_create_bitmap = cfuncproto( 
 7182              load_so_libforms(), "fl_create_bitmap", 
 7183              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7184              FL_Coord, STRING], 
 7185              """FL_OBJECT * fl_create_bitmap(int type, FL_Coord x, FL_Coord y, 
 7186                 FL_Coord w, FL_Coord h, const char * label) 
 7187              """) 
 7188      check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 
 7189      ibitmaptype = convert_to_int(bitmaptype) 
 7190      ix = convert_to_FL_Coord(x) 
 7191      iy = convert_to_FL_Coord(y) 
 7192      iw = convert_to_FL_Coord(w) 
 7193      ih = convert_to_FL_Coord(h) 
 7194      slabel = convert_to_int(label) 
 7195      keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, 
 7196                     iw, ih, slabel) 
 7197      retval = _fl_create_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 
 7198      return retval 
 7199   
 7200   
 7201 -def fl_add_bitmap(bitmaptype, x, y, w, h, label): 
 7202      """ 
 7203          fl_add_bitmap(bitmaptype, x, y, w, h, label) -> pObject 
 7204   
 7205          Adds a bitmap object. 
 7206   
 7207          @param bitmaptype : type of bitmap to be added 
 7208          @param x : horizontal position of bitmap (upper-left corner) 
 7209          @param y : vertical position of bitmap (upper-left corner) 
 7210          @param w : width of bitmap in pixels 
 7211          @param h : height of bitmap in pixels 
 7212          @param label : text label of bitmap 
 7213      """ 
 7214   
 7215      _fl_add_bitmap = cfuncproto( 
 7216              load_so_libforms(), "fl_add_bitmap", 
 7217              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7218              FL_Coord, STRING], 
 7219              """FL_OBJECT * fl_add_bitmap(int type, FL_Coord x, FL_Coord y, 
 7220                 FL_Coord w, FL_Coord h, const char * label) 
 7221              """) 
 7222      check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 
 7223      ibitmaptype = convert_to_int(bitmaptype) 
 7224      ix = convert_to_FL_Coord(x) 
 7225      iy = convert_to_FL_Coord(y) 
 7226      iw = convert_to_FL_Coord(w) 
 7227      ih = convert_to_FL_Coord(h) 
 7228      slabel = convert_to_string(label) 
 7229      keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, iw, 
 7230                     ih, slabel) 
 7231      retval = _fl_add_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 
 7232      return retval 
 7233   
 7234   
 7235 -def fl_set_bitmap_data(pObject, w, h, xbmcontents): 
 7236      """ fl_set_bitmap_data(pObject, w, h, xbmcontents) 
 7237   
 7238          Fills the bitmap with a bitmap. 
 7239   
 7240          @param pObject : pointer to object 
 7241          @param w : width of bitmap in pixels 
 7242          @param h : height of bitmap in pixels 
 7243          @param xbmcontents : bitmap data used for contents in ubytes 
 7244      """ 
 7245   
 7246      _fl_set_bitmap_data = cfuncproto( 
 7247              load_so_libforms(), "fl_set_bitmap_data", 
 7248              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
 7249              cty.POINTER(cty.c_ubyte)], 
 7250              """void fl_set_bitmap_data(FL_OBJECT * ob, int w, int h, 
 7251                 unsigned char * data) 
 7252              """) 
 7253      iw = convert_to_int(w) 
 7254      ih = convert_to_int(h) 
 7255      pxbmcontents = cty.cast(xbmcontents, cty.POINTER(cty.c_ubyte)) 
 7256      keep_elem_refs(pObject, w, h, xbmcontents, iw, ih, pxbmcontents) 
 7257      _fl_set_bitmap_data(pObject, iw, ih, pxbmcontents) 
 7258   
 7259   
 7260 -def fl_set_bitmap_file(pObject, fname): 
 7261      """ fl_set_bitmap_file(pObject, fname) 
 7262   
 7263          @param pObject : pointer to object 
 7264          @param fname : name of bitmap file 
 7265      """ 
 7266   
 7267      _fl_set_bitmap_file = cfuncproto( 
 7268              load_so_libforms(), "fl_set_bitmap_file", 
 7269              None, [cty.POINTER(FL_OBJECT), STRING], 
 7270              """void fl_set_bitmap_file(FL_OBJECT * ob, const char * fname) 
 7271              """) 
 7272      sfname = convert_to_string(fname) 
 7273      keep_elem_refs(pObject, fname, sfname) 
 7274      _fl_set_bitmap_file(pObject, sfname) 
 7275   
 7276   
 7277 -def fl_read_bitmapfile(win, filename, w, h, hotx, hoty): 
 7278      """ fl_read_bitmapfile(win, filename, w, h, hotx, hoty) -> pixmap 
 7279      """ 
 7280   
 7281      _fl_read_bitmapfile = cfuncproto( 
 7282              load_so_libforms(), "fl_read_bitmapfile", 
 7283              Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 
 7284              cty.POINTER(cty.c_uint), cty.POINTER(cty.c_int), 
 7285              cty.POINTER(cty.c_int)], 
 7286              """Pixmap fl_read_bitmapfile(Window win, const char * file, 
 7287                 unsigned int * w, unsigned int * h, int * hotx, int * hoty) 
 7288              """) 
 7289      ulwin = convert_to_Window(win) 
 7290      sfilename = convert_to_string(filename) 
 7291      pw = cty.cast(w, cty.POINTER(cty.c_uint)) 
 7292      ph = cty.cast(h, cty.POINTER(cty.c_uint)) 
 7293      photx = cty.cast(hotx, cty.POINTER(cty.c_int)) 
 7294      photy = cty.cast(hoty, cty.POINTER(cty.c_int)) 
 7295      keep_elem_refs(win, filename, w, h, hotx, hoty, ulwin, sfilename, 
 7296                     pw, ph, photx, photy) 
 7297      retval = _fl_read_bitmapfile(ulwin, sfilename, pw, ph, photx, photy) 
 7298      return retval 
 7299   
 7300   
 7301 -def fl_create_from_bitmapdata(win, data, w, h): 
 7302      """ 
 7303           fl_create_from_bitmapdata(win, data, w, h) -> pixmap 
 7304   
 7305           @param win : window 
 7306           @param data : bitmap data 
 7307           @param w : width of bitmap in pixels 
 7308           @param h : height of bitmap in pixels 
 7309      """ 
 7310   
 7311      _fl_create_from_bitmapdata = cfuncproto( 
 7312              load_so_libforms(), "fl_create_from_bitmapdata", 
 7313              Pixmap, [Window, STRING, cty.c_int, cty.c_int], 
 7314              """Pixmap fl_create_from_bitmapdata(Window win, const 
 7315                 char * data, int width, int height) 
 7316              """) 
 7317      ulwin = convert_to_ulong(win) 
 7318      sdata = convert_to_string(data) 
 7319      iw = convert_to_int(w) 
 7320      ih = convert_to_int(h) 
 7321      keep_elem_refs(win, data, w, h, ulwin, sdata, iw, ih) 
 7322      retval = _fl_create_from_bitmapdata(ulwin, sdata, iw, ih) 
 7323      return retval 
 7324   
 7325   
 7326  # for compatibility 
 7327  fl_set_bitmap_datafile = fl_set_bitmap_file 
 7328   
 7329   
 7330  # PIXMAP stuff 
 7331   
 7332 -def fl_create_pixmap(pixmaptype, x, y, w, h, label): 
 7333      """ fl_create_pixmap(pixmaptype, x, y, w, h, label) -> pObject 
 7334      """ 
 7335   
 7336      _fl_create_pixmap = cfuncproto( 
 7337              load_so_libforms(), "fl_create_pixmap", 
 7338              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7339              FL_Coord, STRING], 
 7340              """FL_OBJECT * fl_create_pixmap(int type, FL_Coord x, FL_Coord y, 
 7341                 FL_Coord w, FL_Coord h, const char * label) 
 7342              """) 
 7343      check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 
 7344      ipixmaptype = convert_to_int(pixmaptype) 
 7345      ix = convert_to_FL_Coord(x) 
 7346      iy = convert_to_FL_Coord(y) 
 7347      iw = convert_to_FL_Coord(w) 
 7348      ih = convert_to_FL_Coord(h) 
 7349      slabel = convert_to_string(label) 
 7350      keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 
 7351                     ih, slabel) 
 7352      retval = _fl_create_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 
 7353      return retval 
 7354   
 7355   
 7356 -def fl_add_pixmap(pixmaptype, x, y, w, h, label): 
 7357      """ fl_add_pixmap(pixmaptype, x, y, w, h, label) -> pObject 
 7358      """ 
 7359   
 7360      _fl_add_pixmap = cfuncproto( 
 7361              load_so_libforms(), "fl_add_pixmap", 
 7362              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7363              FL_Coord, STRING], 
 7364              """FL_OBJECT * fl_add_pixmap(int type, FL_Coord x, FL_Coord y, 
 7365                 FL_Coord w, FL_Coord h, const char * label) 
 7366              """) 
 7367      check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 
 7368      ipixmaptype = convert_to_int(pixmaptype) 
 7369      ix = convert_to_FL_Coord(x) 
 7370      iy = convert_to_FL_Coord(y) 
 7371      iw = convert_to_FL_Coord(w) 
 7372      ih = convert_to_FL_Coord(h) 
 7373      slabel = convert_to_string(label) 
 7374      keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 
 7375                     ih, slabel) 
 7376      retval = _fl_add_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 
 7377      return retval 
 7378   
 7379   
 7380 -def fl_set_pixmap_data(pObject, bits): 
 7381      """ fl_set_pixmap_data(pObject, bits) 
 7382      """ 
 7383   
 7384      _fl_set_pixmap_data = cfuncproto( 
 7385              load_so_libforms(), "fl_set_pixmap_data", 
 7386              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 
 7387              """void fl_set_pixmap_data(FL_OBJECT * ob, char * * bits) 
 7388              """) 
 7389      keep_elem_refs(pObject, bits) 
 7390      _fl_set_pixmap_data(pObject, bits) 
 7391   
 7392   
 7393 -def fl_set_pixmap_file(pObject, fname): 
 7394      """ fl_set_pixmap_file(pObject, fname) 
 7395   
 7396          @param pObject : pointer to object 
 7397          @param fname : name of the pixmap file 
 7398      """ 
 7399   
 7400      _fl_set_pixmap_file = cfuncproto( 
 7401              load_so_libforms(), "fl_set_pixmap_file", 
 7402              None, [cty.POINTER(FL_OBJECT), STRING], 
 7403              """void fl_set_pixmap_file(FL_OBJECT * ob, const char * fname) 
 7404              """) 
 7405      sfname = convert_to_string(fname) 
 7406      keep_elem_refs(pObject, fname, sfname) 
 7407      _fl_set_pixmap_file(pObject, sfname) 
 7408   
 7409   
 7410 -def fl_set_pixmap_align(pObject, align, xmargin, ymargin): 
 7411      """ fl_set_pixmap_align(pObject, align, xmargin, ymargin) 
 7412      """ 
 7413   
 7414      _fl_set_pixmap_align = cfuncproto( 
 7415              load_so_libforms(), "fl_set_pixmap_align", 
 7416              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_int], 
 7417              """void fl_set_pixmap_align(FL_OBJECT * ob, int align, 
 7418                 int xmargin, int ymargin) 
 7419              """) 
 7420      check_admitted_listvalues(align, ALIGN_list) 
 7421      ialign = convert_to_int(align) 
 7422      ixmargin = convert_to_int(xmargin) 
 7423      iymargin = convert_to_int(ymargin) 
 7424      keep_elem_refs(pObject, align, xmargin, ymargin, ialign, ixmargin, 
 7425                     iymargin) 
 7426      _fl_set_pixmap_align(pObject, ialign, ixmargin, iymargin) 
 7427   
 7428   
 7429 -def fl_set_pixmap_pixmap(pObject, idnum, mask): 
 7430      """ fl_set_pixmap_pixmap(pObject, idnum, mask) 
 7431      """ 
 7432   
 7433      _fl_set_pixmap_pixmap = cfuncproto( 
 7434              load_so_libforms(), "fl_set_pixmap_pixmap", 
 7435              None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 
 7436              """void fl_set_pixmap_pixmap(FL_OBJECT * ob, Pixmap id, 
 7437                 Pixmap mask) 
 7438              """) 
 7439      ulidnum = convert_to_ulong(idnum) 
 7440      ulmask = convert_to_ulong(mask) 
 7441      keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 
 7442      _fl_set_pixmap_pixmap(pObject, ulidnum, ulmask) 
 7443   
 7444   
 7445 -def fl_set_pixmap_colorcloseness(red, green, blue): 
 7446      """ fl_set_pixmap_colorcloseness(red, green, blue) 
 7447      """ 
 7448   
 7449      _fl_set_pixmap_colorcloseness = cfuncproto( 
 7450              load_so_libforms(), "fl_set_pixmap_colorcloseness", 
 7451              None, [cty.c_int, cty.c_int, cty.c_int], 
 7452              """void fl_set_pixmap_colorcloseness(int red, int green, int blue) 
 7453              """) 
 7454      ired = convert_to_int(red) 
 7455      igreen = convert_to_int(green) 
 7456      iblue = convert_to_int(blue) 
 7457      keep_elem_refs(red, green, blue, ired, igreen, iblue) 
 7458      _fl_set_pixmap_colorcloseness(ired, igreen, iblue) 
 7459   
 7460   
 7461 -def fl_free_pixmap_pixmap(pObject): 
 7462      """ fl_free_pixmap_pixmap(pObject) 
 7463   
 7464          @param pObject : pointer to object 
 7465      """ 
 7466   
 7467      _fl_free_pixmap_pixmap = cfuncproto( 
 7468              load_so_libforms(), "fl_free_pixmap_pixmap", 
 7469              None, [cty.POINTER(FL_OBJECT)], 
 7470              """void fl_free_pixmap_pixmap(FL_OBJECT * ob) 
 7471              """) 
 7472      keep_elem_refs(pObject) 
 7473      _fl_free_pixmap_pixmap(pObject) 
 7474   
 7475   
 7476  #def fl_get_pixmap_pixmap(pObject, p, m)       *API change* 
 7477 -def fl_get_pixmap_pixmap(pObject): 
 7478      """ fl_get_pixmap_pixmap(pObject) -> pixmap, pPixmap, pPixmap_mask 
 7479   
 7480          @param pObject : pointer to object 
 7481      """ 
 7482   
 7483      _fl_get_pixmap_pixmap = cfuncproto( 
 7484              load_so_libforms(), "fl_get_pixmap_pixmap", 
 7485              Pixmap, [cty.POINTER(FL_OBJECT), cty.POINTER(Pixmap), 
 7486              cty.POINTER(Pixmap)], 
 7487              """Pixmap fl_get_pixmap_pixmap(FL_OBJECT * ob, Pixmap * p, 
 7488                 Pixmap * m) 
 7489              """) 
 7490      p, pp = make_ulong_and_pointer() 
 7491      m, pm = make_ulong_and_pointer() 
 7492      keep_elem_refs(pObject, p, m, pp, pm) 
 7493      retval = _fl_get_pixmap_pixmap(pObject, pp, pm) 
 7494      return retval, p, m 
 7495   
 7496   
 7497  #def fl_read_pixmapfile(win, filename, w, h, shape_mask, hotx, hoty, tran)       *API change* 
 7498 -def fl_read_pixmapfile(win, filename, tran): 
 7499      """ fl_read_pixmapfile(win, filename, tran) -> pixmap, w, h, shapemask, hotx, hoty 
 7500      """ 
 7501   
 7502      _fl_read_pixmapfile = cfuncproto( 
 7503              load_so_libforms(), "fl_read_pixmapfile", 
 7504              Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 
 7505              cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 
 7506              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 
 7507              """Pixmap fl_read_pixmapfile(Window win, const char * file, 
 7508                 unsigned int * w, unsigned int * h, Pixmap * shape_mask, 
 7509                 int * hotx, int * hoty, FL_COLOR tran) 
 7510              """) 
 7511      check_admitted_listvalues(tran, COLOR_list) 
 7512      ulwin = convert_to_Window(win) 
 7513      sfilename = convert_to_string(filename) 
 7514      ultran = convert_to_FL_COLOR(tran) 
 7515      w, pw = make_uint_and_pointer() 
 7516      h, ph = make_uint_and_pointer() 
 7517      shapemask, pshapemask = make_ulong_and_pointer() 
 7518      hotx, photx = make_int_and_pointer() 
 7519      hoty, photy = make_int_and_pointer() 
 7520      keep_elem_refs(win, filename, w, h, shapemask, hotx, hoty, tran, ulwin, 
 7521                     sfilename, ultran, pw, ph, pshapemask, photx, photy) 
 7522      retval = _fl_read_pixmapfile(ulwin, sfilename, pw, ph, pshapemask, \ 
 7523                                   photx, photy, ultran) 
 7524      return retval, w, h, shapemask, hotx, hoty 
 7525   
 7526   
 7527 -def fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran): 
 7528      """ fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran) -> pixmap 
 7529      """ 
 7530   
 7531      _fl_create_from_pixmapdata = cfuncproto( 
 7532              load_so_libforms(), "fl_create_from_pixmapdata", 
 7533              Pixmap, [Window, cty.POINTER(STRING), cty.POINTER(cty.c_uint), 
 7534              cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 
 7535              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 
 7536              """Pixmap fl_create_from_pixmapdata(Window win, char * * data, 
 7537              unsigned int * w, unsigned int * h, Pixmap * sm, int * hotx, 
 7538              int * hoty, FL_COLOR tran) 
 7539              """) 
 7540      check_admitted_listvalues(tran, COLOR_list) 
 7541      ulwin = convert_to_Window(win) 
 7542      ultran = convert_to_FL_COLOR(tran) 
 7543      keep_elem_refs(win, data, w, h, sm, hotx, hoty, tran, ulwin, ultran) 
 7544      retval = _fl_create_from_pixmapdata(ulwin, data, w, h, sm, hotx, hoty, 
 7545                                          ultran) 
 7546      return retval 
 7547   
 7548   
 7549 -def fl_free_pixmap(idnum): 
 7550      """ fl_free_pixmap(idnum) 
 7551   
 7552          @param idnum : Pixmap id to be freed 
 7553      """ 
 7554   
 7555      _fl_free_pixmap = cfuncproto( 
 7556              load_so_libforms(), "fl_free_pixmap", 
 7557              None, [Pixmap], 
 7558              """void fl_free_pixmap(Pixmap id) 
 7559              """) 
 7560      ulidnum = convert_to_Pixmap(idnum) 
 7561      keep_elem_refs(idnum, ulidnum) 
 7562      _fl_free_pixmap(ulidnum) 
 7563   
 7564   
 7565  ################## 
 7566  # forms.h (box.h) 
 7567  ################## 
 7568   
 7569 -def fl_create_box(boxtype, x, y, w, h, label): 
 7570      """ 
 7571          fl_create_box(boxtype, x, y, w, h, label) -> pObject 
 7572   
 7573          Creates a box object. 
 7574   
 7575          @param boxtype : type of the box to be created 
 7576          @param x : horizontal position of box (upper-left corner) 
 7577          @param y : vertical position of box (upper-left corner) 
 7578          @param w : width of box in pixel 
 7579          @param h : height of box in pixel 
 7580          @param label : text label of box 
 7581      """ 
 7582   
 7583      _fl_create_box = cfuncproto( 
 7584              load_so_libforms(), "fl_create_box", 
 7585              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7586              FL_Coord, STRING], 
 7587              """FL_OBJECT * fl_create_box(int type, FL_Coord x, FL_Coord y, 
 7588                 FL_Coord w, FL_Coord h, const char * label) 
 7589              """) 
 7590      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 7591      iboxtype = convert_to_int(boxtype) 
 7592      ix = convert_to_FL_Coord(x) 
 7593      iy = convert_to_FL_Coord(y) 
 7594      iw = convert_to_FL_Coord(w) 
 7595      ih = convert_to_FL_Coord(h) 
 7596      slabel = convert_to_string(label) 
 7597      keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 
 7598                     ih, slabel) 
 7599      retval = _fl_create_box(iboxtype, ix, iy, iw, ih, slabel) 
 7600      return retval 
 7601   
 7602   
 7603 -def fl_add_box(boxtype, x, y, w, h, label): 
 7604      """ 
 7605          fl_add_box(boxtype, x, y, w, h, label) -> pObject 
 7606   
 7607          Adds a box object. 
 7608   
 7609          @param boxtype : type of the box to be added 
 7610          @param x : horizontal position of box (upper-left corner) 
 7611          @param y : vertical position of box (upper-left corner) 
 7612          @param w : width of box in pixel 
 7613          @param h : height of box in pixel 
 7614          @param label : text label of box 
 7615      """ 
 7616   
 7617      _fl_add_box = cfuncproto( 
 7618              load_so_libforms(), "fl_add_box", 
 7619              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7620              FL_Coord, STRING], 
 7621              """FL_OBJECT * fl_add_box(int type, FL_Coord x, FL_Coord y, 
 7622                 FL_Coord w, FL_Coord h, const char * label) 
 7623              """) 
 7624      check_admitted_listvalues(boxtype, BOXTYPE_list) 
 7625      iboxtype = convert_to_int(boxtype) 
 7626      ix = convert_to_FL_Coord(x) 
 7627      iy = convert_to_FL_Coord(y) 
 7628      iw = convert_to_FL_Coord(w) 
 7629      ih = convert_to_FL_Coord(h) 
 7630      slabel = convert_to_string(label) 
 7631      keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 
 7632                     ih, slabel) 
 7633      retval = _fl_add_box(iboxtype, ix, iy, iw, ih, slabel) 
 7634      return retval 
 7635   
 7636   
 7637   
 7638  ####################### 
 7639  # forms.h (browser.h) 
 7640  # Object class Browser 
 7641  ####################### 
 7642   
 7643  # Routines 
 7644   
 7645 -def fl_create_browser(browsertype, x, y, w, h, label): 
 7646      """ 
 7647          fl_create_browser(browsertype, x, y, w, h, label) -> pObject 
 7648   
 7649          Creates a browser object. 
 7650   
 7651          @param browsertype : type of the browser to be created 
 7652          @param x : horizontal position of browser (upper-left corner) 
 7653          @param y : vertical position of browser (upper-left corner) 
 7654          @param w : width of browser in pixel 
 7655          @param h : height of browser in pixel 
 7656          @param label : text label of browser 
 7657      """ 
 7658   
 7659      _fl_create_browser = cfuncproto( 
 7660              load_so_libforms(), "fl_create_browser", 
 7661              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7662              FL_Coord, STRING], 
 7663              """FL_OBJECT * fl_create_browser(int type, FL_Coord x, FL_Coord y, 
 7664                 FL_Coord w, FL_Coord h, const char * label) 
 7665              """) 
 7666      check_admitted_listvalues(browsertype, BROWSERTYPE_list) 
 7667      ibrowsertype = convert_to_int(browsertype) 
 7668      ix = convert_to_FL_Coord(x) 
 7669      iy = convert_to_FL_Coord(y) 
 7670      iw = convert_to_FL_Coord(w) 
 7671      ih = convert_to_FL_Coord(h) 
 7672      slabel = convert_to_string(label) 
 7673      keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 
 7674                     ih, slabel) 
 7675      retval = _fl_create_browser(ibrowsertype, ix, iy, iw, ih, slabel) 
 7676      return retval 
 7677   
 7678   
 7679 -def fl_add_browser(browsertype, x, y, w, h, label): 
 7680      """ 
 7681          fl_add_browser(browsertype, x, y, w, h, label) -> pObject 
 7682   
 7683          Adds a browser object. 
 7684   
 7685          @param browsertype : type of the browser to be added 
 7686          @param x : horizontal position of browser (upper-left corner) 
 7687          @param y : vertical position of browser (upper-left corner) 
 7688          @param w : width of browser in pixels 
 7689          @param h : height of browser in pixels 
 7690          @param label : text label of browser 
 7691      """ 
 7692   
 7693      _fl_add_browser = cfuncproto( 
 7694              load_so_libforms(), "fl_add_browser", 
 7695              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 7696              FL_Coord, STRING], 
 7697              """FL_OBJECT * fl_add_browser(int type, FL_Coord x, FL_Coord y, 
 7698                 FL_Coord w, FL_Coord h, const char * label) 
 7699              """) 
 7700      check_admitted_listvalues(browsertype, BROWSERTYPE_list) 
 7701      ibrowsertype = convert_to_int(browsertype) 
 7702      ix = convert_to_FL_Coord(x) 
 7703      iy = convert_to_FL_Coord(y) 
 7704      iw = convert_to_FL_Coord(w) 
 7705      ih = convert_to_FL_Coord(h) 
 7706      slabel = convert_to_string(label) 
 7707      keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 
 7708                     ih, slabel) 
 7709      retval = _fl_add_browser(ibrowsertype, ix, iy, iw, ih, slabel) 
 7710      return retval 
 7711   
 7712   
 7713 -def fl_clear_browser(pObject): 
 7714      """ 
 7715          fl_clear_browser(pObject) 
 7716   
 7717          Clears browser object's contents. 
 7718   
 7719          @param pObject : poiter to browser object 
 7720      """ 
 7721   
 7722      _fl_clear_browser = cfuncproto( 
 7723              load_so_libforms(), "fl_clear_browser", 
 7724              None, [cty.POINTER(FL_OBJECT)], 
 7725              """void fl_clear_browser(FL_OBJECT * ob) 
 7726              """) 
 7727      keep_elem_refs(pObject) 
 7728      _fl_clear_browser(pObject) 
 7729   
 7730   
 7731 -def fl_add_browser_line(pObject, newtext): 
 7732      """ 
 7733          fl_add_browser_line(pObject, newtext) 
 7734   
 7735          Add a line to a browser object. 
 7736   
 7737          @param pObject : pointer to browser object 
 7738          @param newtext : line of text to be added 
 7739      """ 
 7740   
 7741      _fl_add_browser_line = cfuncproto( 
 7742              load_so_libforms(), "fl_add_browser_line", 
 7743              None, [cty.POINTER(FL_OBJECT), STRING], 
 7744              """void fl_add_browser_line(FL_OBJECT * ob, const char * newtext) 
 7745              """) 
 7746      snewtext = convert_to_string(newtext) 
 7747      keep_elem_refs(pObject, newtext, snewtext) 
 7748      _fl_add_browser_line(pObject, snewtext) 
 7749   
 7750   
 7751 -def fl_addto_browser(pObject, newtext): 
 7752      """ fl_addto_browser(pObject, newtext) 
 7753      """ 
 7754   
 7755      _fl_addto_browser = cfuncproto( 
 7756              load_so_libforms(), "fl_addto_browser", 
 7757              None, [cty.POINTER(FL_OBJECT), STRING], 
 7758              """void fl_addto_browser(FL_OBJECT * ob, const char * newtext) 
 7759              """) 
 7760      snewtext = convert_to_string(newtext) 
 7761      keep_elem_refs(pObject, newtext, snewtext) 
 7762      _fl_addto_browser(pObject, snewtext) 
 7763   
 7764   
 7765 -def fl_addto_browser_chars(pObject, browsertext): 
 7766      """ fl_addto_browser_chars(pObject, browsertext) 
 7767      """ 
 7768   
 7769      _fl_addto_browser_chars = cfuncproto( 
 7770              load_so_libforms(), "fl_addto_browser_chars", 
 7771              None, [cty.POINTER(FL_OBJECT), STRING], 
 7772              """void fl_addto_browser_chars(FL_OBJECT * ob, const char * str) 
 7773              """) 
 7774      sbrowsertext = convert_to_string(browsertext) 
 7775      keep_elem_refs(pObject, browsertext, sbrowsertext) 
 7776      _fl_addto_browser_chars(pObject, sbrowsertext) 
 7777   
 7778   
 7779  fl_append_browser = fl_addto_browser_chars 
 7780   
 7781   
 7782 -def fl_insert_browser_line(pObject, linenumb, newtext): 
 7783      """ fl_insert_browser_line(pObject, linenumb, newtext) 
 7784      """ 
 7785   
 7786      _fl_insert_browser_line = cfuncproto( 
 7787              load_so_libforms(), "fl_insert_browser_line", 
 7788              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
 7789              """void fl_insert_browser_line(FL_OBJECT * ob, int linenumb, 
 7790                 const char * newtext) 
 7791              """) 
 7792      ilinenumb = convert_to_int(linenumb) 
 7793      snewtext = convert_to_string(newtext) 
 7794      keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 
 7795      _fl_insert_browser_line(pObject, ilinenumb, snewtext) 
 7796   
 7797   
 7798 -def fl_delete_browser_line(pObject, linenumb): 
 7799      """ fl_delete_browser_line(pObject, linenumb) 
 7800      """ 
 7801   
 7802      _fl_delete_browser_line = cfuncproto( 
 7803              load_so_libforms(), "fl_delete_browser_line", 
 7804              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7805              """void fl_delete_browser_line(FL_OBJECT * ob, int linenumb) 
 7806              """) 
 7807      ilinenumb = convert_to_int(linenumb) 
 7808      keep_elem_refs(pObject, linenumb, ilinenumb) 
 7809      _fl_delete_browser_line(pObject, ilinenumb) 
 7810   
 7811   
 7812 -def fl_replace_browser_line(pObject, linenumb, newtext): 
 7813      """ fl_replace_browser_line(pObject, linenumb, newtext) 
 7814      """ 
 7815   
 7816      _fl_replace_browser_line = cfuncproto( 
 7817              load_so_libforms(), "fl_replace_browser_line", 
 7818              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
 7819              """void fl_replace_browser_line(FL_OBJECT * ob, int linenumb, 
 7820                 const char * newtext) 
 7821              """) 
 7822      ilinenumb = convert_to_int(linenumb) 
 7823      snewtext = convert_to_string(newtext) 
 7824      keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 
 7825      _fl_replace_browser_line(pObject, ilinenumb, snewtext) 
 7826   
 7827   
 7828 -def fl_get_browser_line(pObject, linenumb): 
 7829      """ fl_get_browser_line(pObject, linenumb) -> line string 
 7830      """ 
 7831   
 7832      _fl_get_browser_line = cfuncproto( 
 7833              load_so_libforms(), "fl_get_browser_line", 
 7834              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7835              """const char * fl_get_browser_line(FL_OBJECT * ob, int linenumb) 
 7836              """) 
 7837      ilinenumb = convert_to_int(linenumb) 
 7838      keep_elem_refs(pObject, linenumb, ilinenumb) 
 7839      retval = _fl_get_browser_line(pObject, ilinenumb) 
 7840      return retval 
 7841   
 7842   
 7843 -def fl_load_browser(pObject, filename): 
 7844      """ fl_load_browser(pObject, filename) -> num. 
 7845      """ 
 7846   
 7847      _fl_load_browser = cfuncproto( 
 7848              load_so_libforms(), "fl_load_browser", 
 7849              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
 7850              """int fl_load_browser(FL_OBJECT * ob, const char * filename) 
 7851              """) 
 7852      sfilename = convert_to_string(filename) 
 7853      keep_elem_refs(pObject, filename, sfilename) 
 7854      retval = _fl_load_browser(pObject, sfilename) 
 7855      return retval 
 7856   
 7857   
 7858 -def fl_select_browser_line(pObject, line): 
 7859      """ fl_select_browser_line(pObject, line) 
 7860      """ 
 7861   
 7862      _fl_select_browser_line = cfuncproto( 
 7863              load_so_libforms(), "fl_select_browser_line", 
 7864              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7865              """void fl_select_browser_line(FL_OBJECT * ob, int line) 
 7866              """) 
 7867      iline = convert_to_int(line) 
 7868      keep_elem_refs(pObject, line, iline) 
 7869      _fl_select_browser_line(pObject, iline) 
 7870   
 7871   
 7872 -def fl_deselect_browser_line(pObject, line): 
 7873      """ fl_deselect_browser_line(pObject, line) 
 7874      """ 
 7875   
 7876      _fl_deselect_browser_line = cfuncproto( 
 7877              load_so_libforms(), "fl_deselect_browser_line", 
 7878              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7879              """void fl_deselect_browser_line(FL_OBJECT * ob, int line) 
 7880              """) 
 7881      iline = convert_to_int(line) 
 7882      keep_elem_refs(pObject, line, iline) 
 7883      _fl_deselect_browser_line(pObject, iline) 
 7884   
 7885   
 7886 -def fl_deselect_browser(pObject): 
 7887      """ fl_deselect_browser(pObject) 
 7888   
 7889          @param pObject : pointer to object 
 7890      """ 
 7891   
 7892      _fl_deselect_browser = cfuncproto( 
 7893              load_so_libforms(), "fl_deselect_browser", 
 7894              None, [cty.POINTER(FL_OBJECT)], 
 7895              """void fl_deselect_browser(FL_OBJECT * ob) 
 7896              """) 
 7897      keep_elem_refs(pObject) 
 7898      _fl_deselect_browser(pObject) 
 7899   
 7900   
 7901 -def fl_isselected_browser_line(pObject, line): 
 7902      """ fl_isselected_browser_line(pObject, line) -> num. 
 7903      """ 
 7904   
 7905      _fl_isselected_browser_line = cfuncproto( 
 7906              load_so_libforms(), "fl_isselected_browser_line", 
 7907              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7908              """int fl_isselected_browser_line(FL_OBJECT * ob, int line) 
 7909              """) 
 7910      iline = convert_to_int(line) 
 7911      keep_elem_refs(pObject, line, iline) 
 7912      retval = _fl_isselected_browser_line(pObject, iline) 
 7913      return retval 
 7914   
 7915   
 7916 -def fl_get_browser_topline(pObject): 
 7917      """ fl_get_browser_topline(pObject) -> num. 
 7918      """ 
 7919   
 7920      _fl_get_browser_topline = cfuncproto( 
 7921              load_so_libforms(), "fl_get_browser_topline", 
 7922              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7923              """int fl_get_browser_topline(FL_OBJECT * ob) 
 7924              """) 
 7925      keep_elem_refs(pObject) 
 7926      retval = _fl_get_browser_topline(pObject) 
 7927      return retval 
 7928   
 7929   
 7930 -def fl_get_browser(pObject): 
 7931      """ fl_get_browser(pObject) -> num. 
 7932      """ 
 7933   
 7934      _fl_get_browser = cfuncproto( 
 7935              load_so_libforms(), "fl_get_browser", 
 7936              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7937              """int fl_get_browser(FL_OBJECT * ob) 
 7938              """) 
 7939      keep_elem_refs(pObject) 
 7940      retval = _fl_get_browser(pObject) 
 7941      return retval 
 7942   
 7943   
 7944 -def fl_get_browser_maxline(pObject): 
 7945      """ fl_get_browser_maxline(pObject) -> line num. 
 7946      """ 
 7947   
 7948      _fl_get_browser_maxline = cfuncproto( 
 7949              load_so_libforms(), "fl_get_browser_maxline", 
 7950              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7951              """int fl_get_browser_maxline(FL_OBJECT * ob) 
 7952              """) 
 7953      keep_elem_refs(pObject) 
 7954      retval = _fl_get_browser_maxline(pObject) 
 7955      return retval 
 7956   
 7957   
 7958 -def fl_get_browser_screenlines(pObject): 
 7959      """ 
 7960          fl_get_browser_screenlines(pObject) -> lines num. 
 7961   
 7962          Returns an approximation of the number of lines shown in the 
 7963          browser. 
 7964   
 7965          @param pObject : pointer to browser object 
 7966      """ 
 7967   
 7968      _fl_get_browser_screenlines = cfuncproto( 
 7969              load_so_libforms(), "fl_get_browser_screenlines", 
 7970              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 7971              """int fl_get_browser_screenlines(FL_OBJECT * ob) 
 7972              """) 
 7973      keep_elem_refs(pObject) 
 7974      retval = _fl_get_browser_screenlines(pObject) 
 7975      return retval 
 7976   
 7977   
 7978 -def fl_set_browser_topline(pObject, line): 
 7979      """ 
 7980          fl_set_browser_topline(pObject, line) 
 7981   
 7982          Moves a line to the top of the browser. 
 7983   
 7984          @param pObject : pointer to browser object 
 7985          @param line : number of text line to be moved to top 
 7986      """ 
 7987   
 7988      _fl_set_browser_topline = cfuncproto( 
 7989              load_so_libforms(), "fl_set_browser_topline", 
 7990              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 7991              """void fl_set_browser_topline(FL_OBJECT * ob, int line) 
 7992              """) 
 7993      iline = convert_to_int(line) 
 7994      keep_elem_refs(pObject, line, iline) 
 7995      _fl_set_browser_topline(pObject, iline) 
 7996   
 7997   
 7998 -def fl_set_browser_bottomline(pObject, line): 
 7999      """ 
 8000          fl_set_browser_bottomline(pObject, line) 
 8001   
 8002          Moves a line to the bottom of the browser. 
 8003   
 8004          @param pObject : pointer to browser object 
 8005          @param line : number of text line to be moved to bottom 
 8006      """ 
 8007   
 8008      _fl_set_browser_bottomline = cfuncproto( 
 8009              load_so_libforms(), "fl_set_browser_bottomline", 
 8010              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8011              """void fl_set_browser_bottomline(FL_OBJECT * ob, int line) 
 8012              """) 
 8013      iline = convert_to_int(line) 
 8014      keep_elem_refs(pObject, line, iline) 
 8015      _fl_set_browser_bottomline(pObject, iline) 
 8016   
 8017   
 8018 -def fl_set_browser_fontsize(pObject, size): 
 8019      """ 
 8020          fl_set_browser_fontsize(pObject, size) 
 8021   
 8022          Sets the font size of a browser object. 
 8023   
 8024          @param pObject : pointer to browser object 
 8025          @param size : font size to be set 
 8026      """ 
 8027   
 8028      _fl_set_browser_fontsize = cfuncproto( 
 8029              load_so_libforms(), "fl_set_browser_fontsize", 
 8030              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8031              """void fl_set_browser_fontsize(FL_OBJECT * ob, int size) 
 8032              """) 
 8033      isize = convert_to_int(size) 
 8034      keep_elem_refs(pObject, size, isize) 
 8035      _fl_set_browser_fontsize(pObject, isize) 
 8036   
 8037   
 8038 -def fl_set_browser_fontstyle(pObject, style): 
 8039      """ 
 8040          fl_set_browser_fontstyle(pObject, style) 
 8041   
 8042          Sets the font style of a browser object. 
 8043   
 8044          @param pObject : pointer to browser object 
 8045          @param style : font style to be set 
 8046      """ 
 8047   
 8048      _fl_set_browser_fontstyle = cfuncproto( 
 8049              load_so_libforms(), "fl_set_browser_fontstyle", 
 8050              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8051              """void fl_set_browser_fontstyle(FL_OBJECT * ob, int style) 
 8052              """) 
 8053      istyle = convert_to_int(style) 
 8054      keep_elem_refs(pObject, style, istyle) 
 8055      _fl_set_browser_fontstyle(pObject, istyle) 
 8056   
 8057   
 8058 -def fl_set_browser_specialkey(pObject, specialkey): 
 8059      """ 
 8060          fl_set_browser_specialkey(pObject, specialkey) 
 8061   
 8062          Sets the escape key used in the text. 
 8063   
 8064          @param pObject : pointer to browser object 
 8065          @param specialkey : escape key to be set 
 8066      """ 
 8067   
 8068      _fl_set_browser_specialkey = cfuncproto( 
 8069              load_so_libforms(), "fl_set_browser_specialkey", 
 8070              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8071              """void fl_set_browser_specialkey(FL_OBJECT * ob, int specialkey) 
 8072              """) 
 8073      ispecialkey = convert_to_int(specialkey) 
 8074      keep_elem_refs(pObject, specialkey, ispecialkey) 
 8075      _fl_set_browser_specialkey(pObject, ispecialkey) 
 8076   
 8077   
 8078 -def fl_set_browser_vscrollbar(pObject, on): 
 8079      """ fl_set_browser_vscrollbar(pObject, on) 
 8080      """ 
 8081   
 8082      _fl_set_browser_vscrollbar = cfuncproto( 
 8083              load_so_libforms(), "fl_set_browser_vscrollbar", 
 8084              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8085              """void fl_set_browser_vscrollbar(FL_OBJECT * ob, int on) 
 8086              """) 
 8087      ion = convert_to_int(on) 
 8088      keep_elem_refs(pObject, on, ion) 
 8089      _fl_set_browser_vscrollbar(pObject, ion) 
 8090   
 8091   
 8092 -def fl_set_browser_hscrollbar(pObject, on): 
 8093      """ fl_set_browser_hscrollbar(pObject, on) 
 8094      """ 
 8095   
 8096      _fl_set_browser_hscrollbar = cfuncproto( 
 8097              load_so_libforms(), "fl_set_browser_hscrollbar", 
 8098              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8099              """void fl_set_browser_hscrollbar(FL_OBJECT * ob, int on) 
 8100              """) 
 8101      ion = convert_to_int(on) 
 8102      keep_elem_refs(pObject, on, ion) 
 8103      _fl_set_browser_hscrollbar(pObject, ion) 
 8104   
 8105   
 8106 -def fl_set_browser_line_selectable(pObject, line, flag): 
 8107      """ fl_set_browser_line_selectable(pObject, line, flag) 
 8108      """ 
 8109   
 8110      _fl_set_browser_line_selectable = cfuncproto( 
 8111              load_so_libforms(), "fl_set_browser_line_selectable", 
 8112              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
 8113              """void fl_set_browser_line_selectable(FL_OBJECT * ob, int line, 
 8114                 int flag) 
 8115              """) 
 8116      iline = convert_to_int(line) 
 8117      iflag = convert_to_int(flag) 
 8118      keep_elem_refs(pObject, line, flag, iline, iflag) 
 8119      _fl_set_browser_line_selectable(pObject, iline, iflag) 
 8120   
 8121   
 8122  #def fl_get_browser_dimension(pObject, x, y, w, h)       *API change* 
 8123 -def fl_get_browser_dimension(pObject): 
 8124      """ 
 8125          fl_get_browser_dimension(pObject) -> hor.xpos, ver.ypos, width, height 
 8126   
 8127          Returns all dimensions of a browser object. 
 8128   
 8129          @param pObject : pointer to browser object 
 8130      """ 
 8131   
 8132      _fl_get_browser_dimension = cfuncproto( 
 8133              load_so_libforms(), "fl_get_browser_dimension", 
 8134              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
 8135              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
 8136              cty.POINTER(FL_Coord)], 
 8137              """void fl_get_browser_dimension(FL_OBJECT * ob, FL_Coord * x, 
 8138                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
 8139              """) 
 8140      x, px = make_FL_Coord_and_pointer() 
 8141      y, py = make_FL_Coord_and_pointer() 
 8142      w, pw = make_FL_Coord_and_pointer() 
 8143      h, ph = make_FL_Coord_and_pointer() 
 8144      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
 8145      _fl_get_browser_dimension(pObject, px, py, pw, ph) 
 8146      return x, y, w, h 
 8147   
 8148   
 8149 -def fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum): 
 8150      """ fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum) 
 8151      """ 
 8152   
 8153      _fl_set_browser_dblclick_callback = cfuncproto( 
 8154              load_so_libforms(), "fl_set_browser_dblclick_callback", 
 8155              None, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, cty.c_long], 
 8156              """void fl_set_browser_dblclick_callback(FL_OBJECT * ob, 
 8157                 FL_CALLBACKPTR cb, long int a) 
 8158              """) 
 8159      largum = convert_to_long(argum) 
 8160      c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 
 8161      keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 
 8162      keep_elem_refs(pObject, argum, largum) 
 8163      _fl_set_browser_dblclick_callback(pObject, c_CallbackPtr, largum) 
 8164   
 8165   
 8166 -def fl_get_browser_xoffset(pObject): 
 8167      """ fl_get_browser_xoffset(pObject) -> coord num. 
 8168   
 8169          @param pObject : pointer to browser object 
 8170      """ 
 8171   
 8172      _fl_get_browser_xoffset = cfuncproto( 
 8173              load_so_libforms(), "fl_get_browser_xoffset", 
 8174              FL_Coord, [cty.POINTER(FL_OBJECT)], 
 8175              """FL_Coord fl_get_browser_xoffset(FL_OBJECT * ob) 
 8176              """) 
 8177      keep_elem_refs(pObject) 
 8178      retval = _fl_get_browser_xoffset(pObject) 
 8179      return retval 
 8180   
 8181   
 8182 -def fl_get_browser_rel_xoffset(pObject): 
 8183      """ fl_get_browser_rel_xoffset(pObject) -> num. 
 8184   
 8185          @param pObject : pointer to browser object 
 8186      """ 
 8187   
 8188      _fl_get_browser_rel_xoffset = cfuncproto( 
 8189              load_so_libforms(), "fl_get_browser_rel_xoffset", 
 8190              cty.c_double, [cty.POINTER(FL_OBJECT)], 
 8191              """double fl_get_browser_rel_xoffset(FL_OBJECT * ob) 
 8192              """) 
 8193      keep_elem_refs(pObject) 
 8194      retval = _fl_get_browser_rel_xoffset(pObject) 
 8195      return retval 
 8196   
 8197   
 8198 -def fl_set_browser_xoffset(pObject, npixels): 
 8199      """ fl_set_browser_xoffset(pObject, npixels) 
 8200      """ 
 8201   
 8202      _fl_set_browser_xoffset = cfuncproto( 
 8203              load_so_libforms(), "fl_set_browser_xoffset", 
 8204              None, [cty.POINTER(FL_OBJECT), FL_Coord], 
 8205              """void fl_set_browser_xoffset(FL_OBJECT * ob, FL_Coord npixels) 
 8206              """) 
 8207      inpixels = convert_to_FL_Coord(npixels) 
 8208      keep_elem_refs(pObject, npixels, inpixels) 
 8209      _fl_set_browser_xoffset(pObject, inpixels) 
 8210   
 8211   
 8212 -def fl_set_browser_rel_xoffset(pObject, val): 
 8213      """ fl_set_browser_rel_xoffset(pObject, val) 
 8214      """ 
 8215   
 8216      _fl_set_browser_rel_xoffset = cfuncproto( 
 8217              load_so_libforms(), "fl_set_browser_rel_xoffset", 
 8218              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
 8219              """void fl_set_browser_rel_xoffset(FL_OBJECT * ob, double val) 
 8220              """) 
 8221      fval = convert_to_double(val) 
 8222      keep_elem_refs(pObject, val, fval) 
 8223      _fl_set_browser_rel_xoffset(pObject, fval) 
 8224   
 8225   
 8226 -def fl_get_browser_yoffset(pObject): 
 8227      """ fl_get_browser_yoffset(pObject) -> coord num. 
 8228      """ 
 8229   
 8230      _fl_get_browser_yoffset = cfuncproto( 
 8231              load_so_libforms(), "fl_get_browser_yoffset", 
 8232              FL_Coord, [cty.POINTER(FL_OBJECT)], 
 8233              """FL_Coord fl_get_browser_yoffset(FL_OBJECT * ob) 
 8234              """) 
 8235      keep_elem_refs(pObject) 
 8236      retval = _fl_get_browser_yoffset(pObject) 
 8237      return retval 
 8238   
 8239   
 8240 -def fl_get_browser_rel_yoffset(pObject): 
 8241      """ fl_get_browser_rel_yoffset(pObject) -> num. 
 8242      """ 
 8243   
 8244      _fl_get_browser_rel_yoffset = cfuncproto( 
 8245              load_so_libforms(), "fl_get_browser_rel_yoffset", 
 8246              cty.c_double, [cty.POINTER(FL_OBJECT)], 
 8247              """double fl_get_browser_rel_yoffset(FL_OBJECT * ob) 
 8248              """) 
 8249      keep_elem_refs(pObject) 
 8250      retval = _fl_get_browser_rel_yoffset(pObject) 
 8251      return retval 
 8252   
 8253   
 8254 -def fl_set_browser_yoffset(pObject, npixels): 
 8255      """ fl_set_browser_yoffset(pObject, npixels) 
 8256      """ 
 8257   
 8258      _fl_set_browser_yoffset = cfuncproto( 
 8259              load_so_libforms(), "fl_set_browser_yoffset", 
 8260              None, [cty.POINTER(FL_OBJECT), FL_Coord], 
 8261              """void fl_set_browser_yoffset(FL_OBJECT * ob, FL_Coord npixels) 
 8262              """) 
 8263      inpixels = convert_to_FL_Coord(npixels) 
 8264      keep_elem_refs(pObject, npixels, inpixels) 
 8265      _fl_set_browser_yoffset(pObject, inpixels) 
 8266   
 8267   
 8268 -def fl_set_browser_rel_yoffset(pObject, val): 
 8269      """ fl_set_browser_rel_yoffset(pObject, val) 
 8270      """ 
 8271   
 8272      _fl_set_browser_rel_yoffset = cfuncproto( 
 8273              load_so_libforms(), "fl_set_browser_rel_yoffset", 
 8274              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
 8275              """void fl_set_browser_rel_yoffset(FL_OBJECT * ob, double val) 
 8276              """) 
 8277      fval = convert_to_double(val) 
 8278      keep_elem_refs(pObject, val, fval) 
 8279      _fl_set_browser_rel_yoffset(pObject, fval) 
 8280   
 8281   
 8282 -def fl_set_browser_scrollbarsize(pObject, hh, vw): 
 8283      """ fl_set_browser_scrollbarsize(pObject, hh, vw) 
 8284      """ 
 8285   
 8286      _fl_set_browser_scrollbarsize = cfuncproto( 
 8287              load_so_libforms(), "fl_set_browser_scrollbarsize", 
 8288              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
 8289              """void fl_set_browser_scrollbarsize(FL_OBJECT * ob, 
 8290                 int hh, int vw) 
 8291              """) 
 8292      ihh = convert_to_int(hh) 
 8293      ivw = convert_to_int(vw) 
 8294      keep_elem_refs(pObject, hh, vw, ihh, ivw) 
 8295      _fl_set_browser_scrollbarsize(pObject, ihh, ivw) 
 8296   
 8297   
 8298 -def fl_show_browser_line(pObject, line): 
 8299      """ 
 8300          fl_show_browser_line(pObject, line) 
 8301   
 8302          Bring a browser line into view. 
 8303   
 8304          @param pObject : pointer to browser object 
 8305          @param line : line to show 
 8306      """ 
 8307   
 8308      _fl_show_browser_line = cfuncproto( 
 8309              load_so_libforms(), "fl_show_browser_line", 
 8310              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8311              """void fl_show_browser_line(FL_OBJECT * ob, int j) 
 8312              """) 
 8313      iline = convert_to_int(line) 
 8314      keep_elem_refs(pObject, line, iline) 
 8315      _fl_show_browser_line(pObject, iline) 
 8316   
 8317   
 8318 -def fl_set_default_browser_maxlinelength(n): 
 8319      """ 
 8320          fl_set_default_browser_maxlinelength(n) -> length num. 
 8321   
 8322          Inactive function. Returns always 0 
 8323   
 8324          @param n : unused parameter 
 8325      """ 
 8326   
 8327      _fl_set_default_browser_maxlinelength = cfuncproto( 
 8328              load_so_libforms(), "fl_set_default_browser_maxlinelength", 
 8329              cty.c_int, [cty.c_int], 
 8330              """int fl_set_default_browser_maxlinelength(int n): 
 8331              """) 
 8332      inum = convert_to_int(n) 
 8333      keep_elem_refs(n, inum) 
 8334      retval = _fl_set_default_browser_maxlinelength(inum) 
 8335      return retval 
 8336   
 8337   
 8338  FL_BROWSER_SCROLL_CALLBACK = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), 
 8339                  cty.c_int, cty.c_void_p) 
 8340   
 8341 -def fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, data): 
 8342      """ 
 8343          fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, 
 8344          data) 
 8345   
 8346          @param pObject : pointer to browser object 
 8347          @param py_BrowserScrollCallback : python function, fn(pObject, num, 
 8348             data) 
 8349          @param data : user data argument 
 8350      """ 
 8351   
 8352      _fl_set_browser_hscroll_callback = cfuncproto( 
 8353              load_so_libforms(), "fl_set_browser_hscroll_callback", 
 8354              None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 
 8355              cty.c_void_p], 
 8356              """void fl_set_browser_hscroll_callback(FL_OBJECT * ob, 
 8357                 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 
 8358              """) 
 8359      c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 
 8360                                  py_BrowserScrollCallback) 
 8361      pdata = cty.cast(data, cty.c_void_p) 
 8362      keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 
 8363      keep_elem_refs(pObject, data, pdata) 
 8364      _fl_set_browser_hscroll_callback(pObject, c_BrowserScrollCallback, pdata) 
 8365   
 8366   
 8367 -def fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, data): 
 8368      """ 
 8369          fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, 
 8370          data) 
 8371   
 8372          @param pObject : pointer to browser object 
 8373          @param py_BrowserScrollCallback : python function, fn(pObject, num, 
 8374             data) 
 8375          @param data : user data argument 
 8376      """ 
 8377   
 8378      _fl_set_browser_vscroll_callback = cfuncproto( 
 8379              load_so_libforms(), "fl_set_browser_vscroll_callback", 
 8380              None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 
 8381              cty.c_void_p], 
 8382              """void fl_set_browser_vscroll_callback(FL_OBJECT * ob, 
 8383                 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 
 8384              """) 
 8385      c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 
 8386                                  py_BrowserScrollCallback) 
 8387      pdata = cty.cast(data, cty.c_void_p) 
 8388      keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 
 8389      keep_elem_refs(pObject, data, pdata) 
 8390      _fl_set_browser_vscroll_callback(pObject, c_BrowserScrollCallback, pdata) 
 8391   
 8392   
 8393 -def fl_get_browser_line_yoffset(pObject, line): 
 8394      """ fl_get_browser_line_yoffset(pObject, line) -> num. 
 8395      """ 
 8396   
 8397      _fl_get_browser_line_yoffset = cfuncproto( 
 8398              load_so_libforms(), "fl_get_browser_line_yoffset", 
 8399              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
 8400              """int fl_get_browser_line_yoffset(FL_OBJECT * obj, int line) 
 8401              """) 
 8402      iline = convert_to_int(line) 
 8403      keep_elem_refs(pObject, line, iline) 
 8404      retval = _fl_get_browser_line_yoffset(pObject, iline) 
 8405      return retval 
 8406   
 8407   
 8408 -def fl_get_browser_hscroll_callback(pObject): 
 8409      """ fl_get_browser_hscroll_callback(pObject) -> callback 
 8410      """ 
 8411   
 8412      _fl_get_browser_hscroll_callback = cfuncproto( 
 8413              load_so_libforms(), "fl_get_browser_hscroll_callback", 
 8414              FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 
 8415              """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_hscroll_callback( 
 8416                 FL_OBJECT * ob) 
 8417              """) 
 8418      keep_elem_refs(pObject) 
 8419      retval = _fl_get_browser_hscroll_callback(pObject) 
 8420      return retval 
 8421   
 8422   
 8423 -def fl_get_browser_vscroll_callback(pObject): 
 8424      """ fl_get_browser_vscroll_callback(pObject) -> callback 
 8425      """ 
 8426   
 8427      _fl_get_browser_vscroll_callback = cfuncproto( 
 8428              load_so_libforms(), "fl_get_browser_vscroll_callback", 
 8429              FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 
 8430              """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_vscroll_callback( 
 8431                 FL_OBJECT * ob) 
 8432              """) 
 8433      keep_elem_refs(pObject) 
 8434      retval = _fl_get_browser_vscroll_callback(pObject) 
 8435      return retval 
 8436   
 8437   
 8438   
 8439  ############################################################# 
 8440  # forms.h (button.h) 
 8441  # All Buttons: regular button, light button and round button 
 8442  ############################################################# 
 8443   
 8444  # Routines 
 8445   
 8446 -def fl_create_button(buttontype, x, y, w, h, label): 
 8447      """ fl_create_button(buttontype, x, y, w, h, label) -> pObject 
 8448   
 8449          Creates a button object. 
 8450   
 8451          @param buttontype : type of button object to be created 
 8452          @param x : horizontal position of button (upper-left corner) 
 8453          @param x : vertical position of button (upper-left corner) 
 8454          @param w : width of button in pixels 
 8455          @param h : height of button in pixels 
 8456          @param label : text label of button 
 8457      """ 
 8458   
 8459      _fl_create_button = cfuncproto( 
 8460              load_so_libforms(), "fl_create_button", 
 8461              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8462              FL_Coord, STRING], 
 8463              """FL_OBJECT * fl_create_button(int type, FL_Coord x, FL_Coord y, 
 8464                 FL_Coord w, FL_Coord h, const char * label) 
 8465              """) 
 8466      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8467      ibuttontype = convert_to_int(buttontype) 
 8468      ix = convert_to_FL_Coord(x) 
 8469      iy = convert_to_FL_Coord(y) 
 8470      iw = convert_to_FL_Coord(w) 
 8471      ih = convert_to_FL_Coord(h) 
 8472      slabel = convert_to_string(label) 
 8473      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8474                     ih, slabel) 
 8475      retval = _fl_create_button(ibuttontype, ix, iy, iw, ih, slabel) 
 8476      return retval 
 8477   
 8478   
 8479 -def fl_create_roundbutton(buttontype, x, y, w, h, label): 
 8480      """ 
 8481          fl_create_roundbutton(buttontype, x, y, w, h, label) -> pObject 
 8482   
 8483          @param buttontype : type of button object to be created 
 8484          @param x : horizontal position of button (upper-left corner) 
 8485          @param x : vertical position of button (upper-left corner) 
 8486          @param w : width of button in pixels 
 8487          @param h : height of button in pixels 
 8488          @param label : text label of button 
 8489      """ 
 8490   
 8491      _fl_create_roundbutton = cfuncproto( 
 8492              load_so_libforms(), "fl_create_roundbutton", 
 8493              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8494              FL_Coord, STRING], 
 8495              """FL_OBJECT * fl_create_roundbutton(int type, FL_Coord x, 
 8496                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8497              """) 
 8498      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8499      ibuttontype = convert_to_int(buttontype) 
 8500      ix = convert_to_FL_Coord(x) 
 8501      iy = convert_to_FL_Coord(y) 
 8502      iw = convert_to_FL_Coord(w) 
 8503      ih = convert_to_FL_Coord(h) 
 8504      slabel = convert_to_string(label) 
 8505      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8506                     ih, slabel) 
 8507      retval = _fl_create_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8508      return retval 
 8509   
 8510   
 8511 -def fl_create_round3dbutton(buttontype, x, y, w, h, label): 
 8512      """ 
 8513          fl_create_round3dbutton(buttontype, x, y, w, h, label) -> pObject 
 8514   
 8515          @param buttontype : type of button object to be created 
 8516          @param x : horizontal position of button (upper-left corner) 
 8517          @param x : vertical position of button (upper-left corner) 
 8518          @param w : width of button in pixels 
 8519          @param h : height of button in pixels 
 8520          @param label : text label of button 
 8521      """ 
 8522   
 8523      _fl_create_round3dbutton = cfuncproto( 
 8524              load_so_libforms(), "fl_create_round3dbutton", 
 8525              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8526              FL_Coord, STRING], 
 8527              """FL_OBJECT * fl_create_round3dbutton(int type, FL_Coord x, 
 8528                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8529              """) 
 8530      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8531      ibuttontype = convert_to_int(buttontype) 
 8532      ix = convert_to_FL_Coord(x) 
 8533      iy = convert_to_FL_Coord(y) 
 8534      iw = convert_to_FL_Coord(w) 
 8535      ih = convert_to_FL_Coord(h) 
 8536      slabel = convert_to_string(label) 
 8537      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8538                     ih, slabel) 
 8539      retval = _fl_create_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8540      return retval 
 8541   
 8542   
 8543 -def fl_create_lightbutton(buttontype, x, y, w, h, label): 
 8544      """ 
 8545          fl_create_lightbutton(buttontype, x, y, w, h, label) -> pObject 
 8546   
 8547          @param buttontype : type of button object to be created 
 8548          @param x : horizontal position of button (upper-left corner) 
 8549          @param x : vertical position of button (upper-left corner) 
 8550          @param w : width of button in pixels 
 8551          @param h : height of button in pixels 
 8552          @param label : text label of button 
 8553      """ 
 8554   
 8555      _fl_create_lightbutton = cfuncproto( 
 8556              load_so_libforms(), "fl_create_lightbutton", 
 8557              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8558              FL_Coord, STRING], 
 8559              """FL_OBJECT * fl_create_lightbutton(int type, FL_Coord x, 
 8560                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8561              """) 
 8562      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8563      ibuttontype = convert_to_int(buttontype) 
 8564      ix = convert_to_FL_Coord(x) 
 8565      iy = convert_to_FL_Coord(y) 
 8566      iw = convert_to_FL_Coord(w) 
 8567      ih = convert_to_FL_Coord(h) 
 8568      slabel = convert_to_string(label) 
 8569      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8570                     ih, slabel) 
 8571      retval = _fl_create_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8572      return retval 
 8573   
 8574   
 8575 -def fl_create_checkbutton(buttontype, x, y, w, h, label): 
 8576      """ 
 8577          fl_create_checkbutton(buttontype, x, y, w, h, label) -> pObject 
 8578   
 8579          Creates a checkbutton object. 
 8580   
 8581          @param buttontype : type of button object to be created 
 8582          @param x : horizontal position of button (upper-left corner) 
 8583          @param x : vertical position of button (upper-left corner) 
 8584          @param w : width of button in pixels 
 8585          @param h : height of button in pixels 
 8586          @param label : text label of button 
 8587      """ 
 8588   
 8589      _fl_create_checkbutton = cfuncproto( 
 8590              load_so_libforms(), "fl_create_checkbutton", 
 8591              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8592              FL_Coord, STRING], 
 8593              """FL_OBJECT * fl_create_checkbutton(int type, FL_Coord x, 
 8594                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8595              """) 
 8596      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8597      ibuttontype = convert_to_int(buttontype) 
 8598      ix = convert_to_FL_Coord(x) 
 8599      iy = convert_to_FL_Coord(y) 
 8600      iw = convert_to_FL_Coord(w) 
 8601      ih = convert_to_FL_Coord(h) 
 8602      slabel = convert_to_string(label) 
 8603      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8604                     ih, slabel) 
 8605      retval = _fl_create_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8606      return retval 
 8607   
 8608   
 8609 -def fl_create_bitmapbutton(buttontype, x, y, w, h, label): 
 8610      """ 
 8611          fl_create_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8612   
 8613          @param buttontype : type of button object to be created 
 8614          @param x : horizontal position of button (upper-left corner) 
 8615          @param x : vertical position of button (upper-left corner) 
 8616          @param w : width of button in pixels 
 8617          @param h : height of button in pixels 
 8618          @param label : text label of button 
 8619      """ 
 8620   
 8621      _fl_create_bitmapbutton = cfuncproto( 
 8622              load_so_libforms(), "fl_create_bitmapbutton", 
 8623              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8624              FL_Coord, STRING], 
 8625              """FL_OBJECT * fl_create_bitmapbutton(int type, FL_Coord x, 
 8626                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8627              """) 
 8628      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8629      ibuttontype = convert_to_int(buttontype) 
 8630      ix = convert_to_FL_Coord(x) 
 8631      iy = convert_to_FL_Coord(y) 
 8632      iw = convert_to_FL_Coord(w) 
 8633      ih = convert_to_FL_Coord(h) 
 8634      slabel = convert_to_string(label) 
 8635      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8636                     ih, slabel) 
 8637      retval = _fl_create_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8638      return retval 
 8639   
 8640   
 8641 -def fl_create_pixmapbutton(buttontype, x, y, w, h, label): 
 8642      """ 
 8643          fl_create_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8644   
 8645          @param buttontype : type of button object to be created 
 8646          @param x : horizontal position of button (upper-left corner) 
 8647          @param x : vertical position of button (upper-left corner) 
 8648          @param w : width of button in pixels 
 8649          @param h : height of button in pixels 
 8650          @param label : text label of button 
 8651      """ 
 8652   
 8653      _fl_create_pixmapbutton = cfuncproto( 
 8654              load_so_libforms(), "fl_create_pixmapbutton", 
 8655              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8656              FL_Coord, STRING], 
 8657              """FL_OBJECT * fl_create_pixmapbutton(int type, FL_Coord x, 
 8658                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8659              """) 
 8660      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8661      ibuttontype = convert_to_int(buttontype) 
 8662      ix = convert_to_FL_Coord(x) 
 8663      iy = convert_to_FL_Coord(y) 
 8664      iw = convert_to_FL_Coord(w) 
 8665      ih = convert_to_FL_Coord(h) 
 8666      slabel = convert_to_string(label) 
 8667      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8668                     ih, slabel) 
 8669      retval = _fl_create_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8670      return retval 
 8671   
 8672   
 8673 -def fl_create_scrollbutton(buttontype, x, y, w, h, label): 
 8674      """ 
 8675          fl_create_scrollbutton(buttontype, x, y, w, h, label) -> pObject 
 8676   
 8677          @param buttontype : type of button object to be created 
 8678          @param x : horizontal position of button (upper-left corner) 
 8679          @param x : vertical position of button (upper-left corner) 
 8680          @param w : width of button in pixels 
 8681          @param h : height of button in pixels 
 8682          @param label : text label of button 
 8683      """ 
 8684   
 8685      _fl_create_scrollbutton = cfuncproto( 
 8686              load_so_libforms(), "fl_create_scrollbutton", 
 8687              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8688              FL_Coord, STRING], 
 8689              """FL_OBJECT * fl_create_scrollbutton(int type, FL_Coord x, 
 8690                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8691              """) 
 8692      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8693      ibuttontype = convert_to_int(buttontype) 
 8694      ix = convert_to_FL_Coord(x) 
 8695      iy = convert_to_FL_Coord(y) 
 8696      iw = convert_to_FL_Coord(w) 
 8697      ih = convert_to_FL_Coord(h) 
 8698      slabel = convert_to_string(label) 
 8699      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8700                     ih, slabel) 
 8701      retval = _fl_create_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8702      return retval 
 8703   
 8704   
 8705 -def fl_create_labelbutton(buttontype, x, y, w, h, label): 
 8706      """ 
 8707          fl_create_labelbutton(buttontype, x, y, w, h, label) -> pObject 
 8708   
 8709          @param buttontype : type of button object to be created 
 8710          @param x : horizontal position of button (upper-left corner) 
 8711          @param x : vertical position of button (upper-left corner) 
 8712          @param w : width of button in pixels 
 8713          @param h : height of button in pixels 
 8714          @param label : text label of button 
 8715      """ 
 8716   
 8717      _fl_create_labelbutton = cfuncproto( 
 8718              load_so_libforms(), "fl_create_labelbutton", 
 8719              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8720              FL_Coord, STRING], 
 8721              """FL_OBJECT * fl_create_labelbutton(int type, FL_Coord x, 
 8722                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8723              """) 
 8724      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8725      ibuttontype = convert_to_int(buttontype) 
 8726      ix = convert_to_FL_Coord(x) 
 8727      iy = convert_to_FL_Coord(y) 
 8728      iw = convert_to_FL_Coord(w) 
 8729      ih = convert_to_FL_Coord(h) 
 8730      slabel = convert_to_string(label) 
 8731      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8732                     ih, slabel) 
 8733      retval = _fl_create_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8734      return retval 
 8735   
 8736   
 8737 -def fl_add_roundbutton(buttontype, x, y, w, h, label): 
 8738      """ 
 8739          fl_add_roundbutton(buttontype, x, y, w, h, label) -> pObject 
 8740   
 8741          @param buttontype : type of button object to be added 
 8742          @param x : horizontal position of button (upper-left corner) 
 8743          @param x : vertical position of button (upper-left corner) 
 8744          @param w : width of button in pixels 
 8745          @param h : height of button in pixels 
 8746          @param label : text label of button 
 8747      """ 
 8748   
 8749      _fl_add_roundbutton = cfuncproto( 
 8750              load_so_libforms(), "fl_add_roundbutton", 
 8751              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8752              FL_Coord, STRING], 
 8753              """FL_OBJECT * fl_add_roundbutton(int type, FL_Coord x, 
 8754                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8755              """) 
 8756      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8757      ibuttontype = convert_to_int(buttontype) 
 8758      ix = convert_to_FL_Coord(x) 
 8759      iy = convert_to_FL_Coord(y) 
 8760      iw = convert_to_FL_Coord(w) 
 8761      ih = convert_to_FL_Coord(h) 
 8762      slabel = convert_to_string(label) 
 8763      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8764                     ih, slabel) 
 8765      retval = _fl_add_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8766      return retval 
 8767   
 8768   
 8769 -def fl_add_round3dbutton(buttontype, x, y, w, h, label): 
 8770      """ 
 8771          fl_add_round3dbutton(buttontype, x, y, w, h, label) -> pObject 
 8772   
 8773          @param buttontype : type of button object to be added 
 8774          @param x : horizontal position of button (upper-left corner) 
 8775          @param x : vertical position of button (upper-left corner) 
 8776          @param w : width of button in pixels 
 8777          @param h : height of button in pixels 
 8778          @param label : text label of button 
 8779      """ 
 8780   
 8781      _fl_add_round3dbutton = cfuncproto( 
 8782              load_so_libforms(), "fl_add_round3dbutton", 
 8783              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8784              FL_Coord, STRING], 
 8785              """FL_OBJECT * fl_add_round3dbutton(int type, FL_Coord x, 
 8786                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8787              """) 
 8788      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8789      ibuttontype = convert_to_int(buttontype) 
 8790      ix = convert_to_FL_Coord(x) 
 8791      iy = convert_to_FL_Coord(y) 
 8792      iw = convert_to_FL_Coord(w) 
 8793      ih = convert_to_FL_Coord(h) 
 8794      slabel = convert_to_string(label) 
 8795      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8796                     ih, slabel) 
 8797      retval = _fl_add_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8798      return retval 
 8799   
 8800   
 8801 -def fl_add_lightbutton(buttontype, x, y, w, h, label): 
 8802      """ 
 8803          fl_add_lightbutton(buttontype, x, y, w, h, label) -> pObject 
 8804   
 8805          @param buttontype : type of button object to be added 
 8806          @param x : horizontal position of button (upper-left corner) 
 8807          @param x : vertical position of button (upper-left corner) 
 8808          @param w : width of button in pixels 
 8809          @param h : height of button in pixels 
 8810          @param label : text label of button 
 8811      """ 
 8812   
 8813      _fl_add_lightbutton = cfuncproto( 
 8814              load_so_libforms(), "fl_add_lightbutton", 
 8815              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8816              FL_Coord, STRING], 
 8817              """FL_OBJECT * fl_add_lightbutton(int type, FL_Coord x, FL_Coord y, 
 8818                 FL_Coord w, FL_Coord h, const char * label) 
 8819              """) 
 8820      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8821      ibuttontype = convert_to_int(buttontype) 
 8822      ix = convert_to_FL_Coord(x) 
 8823      iy = convert_to_FL_Coord(y) 
 8824      iw = convert_to_FL_Coord(w) 
 8825      ih = convert_to_FL_Coord(h) 
 8826      slabel = convert_to_string(label) 
 8827      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8828                     ih, slabel) 
 8829      retval = _fl_add_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8830      return retval 
 8831   
 8832   
 8833 -def fl_add_checkbutton(buttontype, x, y, w, h, label): 
 8834      """ 
 8835          fl_add_checkbutton(buttontype, x, y, w, h, label) -> pObject 
 8836   
 8837          Adds a checkbutton object. 
 8838   
 8839          @param buttontype : type of button object to be added 
 8840          @param x : horizontal position of button (upper-left corner) 
 8841          @param x : vertical position of button (upper-left corner) 
 8842          @param w : width of button in pixels 
 8843          @param h : height of button in pixels 
 8844          @param label : text label of button 
 8845      """ 
 8846   
 8847      _fl_add_checkbutton = cfuncproto( 
 8848              load_so_libforms(), "fl_add_checkbutton", 
 8849              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8850              FL_Coord, STRING], 
 8851              """FL_OBJECT * fl_add_checkbutton(int type, FL_Coord x, FL_Coord y, 
 8852                 FL_Coord w, FL_Coord h, const char * label) 
 8853              """) 
 8854      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8855      ibuttontype = convert_to_int(buttontype) 
 8856      ix = convert_to_FL_Coord(x) 
 8857      iy = convert_to_FL_Coord(y) 
 8858      iw = convert_to_FL_Coord(w) 
 8859      ih = convert_to_FL_Coord(h) 
 8860      slabel = convert_to_string(label) 
 8861      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8862                     ih, slabel) 
 8863      retval = _fl_add_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8864      return retval 
 8865   
 8866   
 8867 -def fl_add_button(buttontype, x, y, w, h, label): 
 8868      """ 
 8869          fl_add_button(buttontype, x, y, w, h, label) -> pObject 
 8870   
 8871          Adds a button to the current form. 
 8872   
 8873          @param buttontype : type of button object to be added 
 8874          @param x : horizontal position of button (upper-left corner) 
 8875          @param x : vertical position of button (upper-left corner) 
 8876          @param w : width of button in pixels 
 8877          @param h : height of button in pixels 
 8878          @param label : text label of button 
 8879      """ 
 8880   
 8881      _fl_add_button = cfuncproto( 
 8882              load_so_libforms(), "fl_add_button", 
 8883              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8884              FL_Coord, STRING], 
 8885              """FL_OBJECT * fl_add_button(int type, FL_Coord x, FL_Coord y, 
 8886                 FL_Coord w, FL_Coord h, const char * label) 
 8887              """) 
 8888      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8889      ibuttontype = convert_to_int(buttontype) 
 8890      ix = convert_to_FL_Coord(x) 
 8891      iy = convert_to_FL_Coord(y) 
 8892      iw = convert_to_FL_Coord(w) 
 8893      ih = convert_to_FL_Coord(h) 
 8894      slabel = convert_to_string(label) 
 8895      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8896                     ih, slabel) 
 8897      retval = _fl_add_button(ibuttontype, ix, iy, iw, ih, slabel) 
 8898      return retval 
 8899   
 8900   
 8901 -def fl_add_bitmapbutton(buttontype, x, y, w, h, label): 
 8902      """ 
 8903          fl_add_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 
 8904   
 8905          @param buttontype : type of button object to be added 
 8906          @param x : horizontal position of button (upper-left corner) 
 8907          @param x : vertical position of button (upper-left corner) 
 8908          @param w : width of button in pixels 
 8909          @param h : height of button in pixels 
 8910          @param label : text label of button 
 8911      """ 
 8912   
 8913      _fl_add_bitmapbutton = cfuncproto( 
 8914              load_so_libforms(), "fl_add_bitmapbutton", 
 8915              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8916              FL_Coord, STRING], 
 8917              """FL_OBJECT * fl_add_bitmapbutton(int type, FL_Coord x, 
 8918                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8919              """) 
 8920      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8921      ibuttontype = convert_to_int(buttontype) 
 8922      ix = convert_to_FL_Coord(x) 
 8923      iy = convert_to_FL_Coord(y) 
 8924      iw = convert_to_FL_Coord(w) 
 8925      ih = convert_to_FL_Coord(h) 
 8926      slabel = convert_to_string(label) 
 8927      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8928                     ih, slabel) 
 8929      retval = _fl_add_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8930      return retval 
 8931   
 8932   
 8933 -def fl_add_scrollbutton(buttontype, x, y, w, h, label): 
 8934      """ 
 8935          fl_add_scrollbutton(buttontype, x, y, w, h, label) -> pObject 
 8936   
 8937          @param buttontype : type of button object to be added 
 8938          @param x : horizontal position of button (upper-left corner) 
 8939          @param x : vertical position of button (upper-left corner) 
 8940          @param w : width of button in pixels 
 8941          @param h : height of button in pixels 
 8942          @param label : text label of button 
 8943      """ 
 8944   
 8945      _fl_add_scrollbutton = cfuncproto( 
 8946              load_so_libforms(), "fl_add_scrollbutton", 
 8947              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8948              FL_Coord, STRING], 
 8949              """FL_OBJECT * fl_add_scrollbutton(int type, FL_Coord x, 
 8950                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8951              """) 
 8952      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8953      ibuttontype = convert_to_int(buttontype) 
 8954      ix = convert_to_FL_Coord(x) 
 8955      iy = convert_to_FL_Coord(y) 
 8956      iw = convert_to_FL_Coord(w) 
 8957      ih = convert_to_FL_Coord(h) 
 8958      slabel = convert_to_string(label) 
 8959      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8960                     ih, slabel) 
 8961      retval = _fl_add_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8962      return retval 
 8963   
 8964   
 8965 -def fl_add_labelbutton(buttontype, x, y, w, h, label): 
 8966      """ 
 8967          fl_add_labelbutton(buttontype, x, y, w, h, label) -> pObject 
 8968   
 8969          @param buttontype : type of button object to be added 
 8970          @param x : horizontal position of button (upper-left corner) 
 8971          @param x : vertical position of button (upper-left corner) 
 8972          @param w : width of button in pixels 
 8973          @param h : height of button in pixels 
 8974          @param label : text label of button 
 8975      """ 
 8976   
 8977      _fl_add_labelbutton = cfuncproto( 
 8978              load_so_libforms(), "fl_add_labelbutton", 
 8979              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 8980              FL_Coord, STRING], 
 8981              """FL_OBJECT * fl_add_labelbutton(int type, FL_Coord x, 
 8982                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 8983              """) 
 8984      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 8985      ibuttontype = convert_to_int(buttontype) 
 8986      ix = convert_to_FL_Coord(x) 
 8987      iy = convert_to_FL_Coord(y) 
 8988      iw = convert_to_FL_Coord(w) 
 8989      ih = convert_to_FL_Coord(h) 
 8990      slabel = convert_to_string(label) 
 8991      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 8992                     ih, slabel) 
 8993      retval = _fl_add_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 8994      return retval 
 8995   
 8996   
 8997  fl_set_bitmapbutton_file = fl_set_bitmap_file 
 8998   
 8999   
 9000 -def fl_set_bitmapbutton_data(pObject, w, h, bits): 
 9001      """ fl_set_bitmapbutton_data(pObject, w, h, bits) 
 9002      """ 
 9003   
 9004      _fl_set_bitmapbutton_data = cfuncproto( 
 9005              load_so_libforms(), "fl_set_bitmapbutton_data", 
 9006              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
 9007              cty.POINTER(cty.c_ubyte)], 
 9008              """void fl_set_bitmapbutton_data(FL_OBJECT * ob, int w, int h, 
 9009                 unsigned char * bits) 
 9010              """) 
 9011      iw = convert_to_int(w) 
 9012      ih = convert_to_int(h) 
 9013      pbits = cty.cast(bits, cty.POINTER(cty.c_ubyte)) 
 9014      keep_elem_refs(pObject, w, h, bits, iw, ih, pbits) 
 9015      _fl_set_bitmapbutton_data(pObject, iw, ih, pbits) 
 9016   
 9017   
 9018  fl_set_bitmapbutton_datafile = fl_set_bitmapbutton_file 
 9019   
 9020   
 9021 -def fl_add_pixmapbutton(buttontype, x, y, w, h, label): 
 9022      """ 
 9023          fl_add_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 
 9024   
 9025          @param buttontype : type of button object to be added 
 9026          @param x : horizontal position of button (upper-left corner) 
 9027          @param x : vertical position of button (upper-left corner) 
 9028          @param w : width of button in pixels 
 9029          @param h : height of button in pixels 
 9030          @param label : text label of button 
 9031      """ 
 9032   
 9033      _fl_add_pixmapbutton = cfuncproto( 
 9034              load_so_libforms(), "fl_add_pixmapbutton", 
 9035              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9036              FL_Coord, STRING], 
 9037              """FL_OBJECT * fl_add_pixmapbutton(int type, FL_Coord x, 
 9038                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
 9039              """) 
 9040      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 9041      ibuttontype = convert_to_int(buttontype) 
 9042      ix = convert_to_FL_Coord(x) 
 9043      iy = convert_to_FL_Coord(y) 
 9044      iw = convert_to_FL_Coord(w) 
 9045      ih = convert_to_FL_Coord(h) 
 9046      slabel = convert_to_string(label) 
 9047      keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 
 9048                     ih, slabel) 
 9049      retval = _fl_add_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 
 9050      return retval 
 9051   
 9052   
 9053 -def fl_set_pixmapbutton_focus_outline(pObject, yes): 
 9054      """ fl_set_pixmapbutton_focus_outline(pObject, yes) 
 9055      """ 
 9056   
 9057      _fl_set_pixmapbutton_focus_outline = cfuncproto( 
 9058              load_so_libforms(), "fl_set_pixmapbutton_focus_outline", 
 9059              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9060              """void fl_set_pixmapbutton_focus_outline(FL_OBJECT * ob, int yes) 
 9061              """) 
 9062      iyes = convert_to_int(yes) 
 9063      keep_elem_refs(pObject, yes, iyes) 
 9064      _fl_set_pixmapbutton_focus_outline(pObject, iyes) 
 9065   
 9066   
 9067  fl_set_pixmapbutton_data = fl_set_pixmap_data 
 9068  fl_set_pixmapbutton_file = fl_set_pixmap_file 
 9069  fl_set_pixmapbutton_pixmap = fl_set_pixmap_pixmap 
 9070  fl_get_pixmapbutton_pixmap = fl_get_pixmap_pixmap 
 9071  fl_set_pixmapbutton_align = fl_set_pixmap_align 
 9072  fl_free_pixmapbutton_pixmap = fl_free_pixmap_pixmap 
 9073  fl_set_pixmapbutton_datafile = fl_set_pixmapbutton_file 
 9074  fl_set_pixmapbutton_show_focus = fl_set_pixmapbutton_focus_outline 
 9075   
 9076   
 9077 -def fl_set_pixmapbutton_focus_data(pObject, bits): 
 9078      """ fl_set_pixmapbutton_focus_data(pObject, bits) 
 9079      """ 
 9080   
 9081      _fl_set_pixmapbutton_focus_data = cfuncproto( 
 9082              load_so_libforms(), "fl_set_pixmapbutton_focus_data", 
 9083              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 
 9084              """void fl_set_pixmapbutton_focus_data(FL_OBJECT * ob, 
 9085                 char * * bits) 
 9086              """) 
 9087      keep_elem_refs(pObject, bits) 
 9088      _fl_set_pixmapbutton_focus_data(pObject, bits) 
 9089   
 9090   
 9091 -def fl_set_pixmapbutton_focus_file(pObject, fname): 
 9092      """ fl_set_pixmapbutton_focus_file(pObject, fname) 
 9093      """ 
 9094   
 9095      _fl_set_pixmapbutton_focus_file = cfuncproto( 
 9096              load_so_libforms(), "fl_set_pixmapbutton_focus_file", 
 9097              None, [cty.POINTER(FL_OBJECT), STRING], 
 9098              """void fl_set_pixmapbutton_focus_file(FL_OBJECT * ob, 
 9099                 const char * fname) 
 9100              """) 
 9101      sfname = convert_to_string(fname) 
 9102      keep_elem_refs(pObject, fname, sfname) 
 9103      _fl_set_pixmapbutton_focus_file(pObject, sfname) 
 9104   
 9105   
 9106 -def fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask): 
 9107      """ fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask) 
 9108      """ 
 9109   
 9110      _fl_set_pixmapbutton_focus_pixmap = cfuncproto( 
 9111              load_so_libforms(), "fl_set_pixmapbutton_focus_pixmap", 
 9112              None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 
 9113              """void fl_set_pixmapbutton_focus_pixmap(FL_OBJECT * ob, 
 9114                 Pixmap id, Pixmap mask) 
 9115              """) 
 9116      ulidnum = convert_to_ulong(idnum) 
 9117      ulmask = convert_to_ulong(mask) 
 9118      keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 
 9119      _fl_set_pixmapbutton_focus_pixmap(pObject, ulidnum, ulmask) 
 9120   
 9121   
 9122 -def fl_get_button(pObject): 
 9123      """ 
 9124          fl_get_button(pObject) -> num. 
 9125   
 9126          Returns the value of the button. 
 9127   
 9128          @param pObject : pointer to button object 
 9129      """ 
 9130   
 9131      _fl_get_button = cfuncproto( 
 9132              load_so_libforms(), "fl_get_button", 
 9133              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9134              """int fl_get_button(FL_OBJECT * ob) 
 9135              """) 
 9136      keep_elem_refs(pObject) 
 9137      retval = _fl_get_button(pObject) 
 9138      return retval 
 9139   
 9140   
 9141 -def fl_set_button(pObject, pushed): 
 9142      """ 
 9143          fl_set_button(pObject, pushed) 
 9144   
 9145          Sets the button state (not pushed/pushed). 
 9146   
 9147          @param pObject : pointer to button object 
 9148          @param pushed : state of button to be set (0|1) 
 9149      """ 
 9150   
 9151      _fl_set_button = cfuncproto( 
 9152              load_so_libforms(), "fl_set_button", 
 9153              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9154              """void fl_set_button(FL_OBJECT * ob, int pushed) 
 9155              """) 
 9156      ipushed = convert_to_int(pushed) 
 9157      keep_elem_refs(pObject, pushed, ipushed) 
 9158      _fl_set_button(pObject, ipushed) 
 9159   
 9160   
 9161 -def fl_get_button_numb(pObject): 
 9162      """ 
 9163          fl_get_button_numb(pObject) -> num. 
 9164   
 9165          Returns the number of the last used  mouse button. fl_mouse_button 
 9166          will also return the mouse number. 
 9167   
 9168          @param pObject : pointer to button object 
 9169      """ 
 9170   
 9171      _fl_get_button_numb = cfuncproto( 
 9172              load_so_libforms(), "fl_get_button_numb", 
 9173              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9174              """int fl_get_button_numb(FL_OBJECT * ob) 
 9175              """) 
 9176      keep_elem_refs(pObject) 
 9177      retval = _fl_get_button_numb(pObject) 
 9178      return retval 
 9179   
 9180   
 9181  fl_set_button_shortcut = fl_set_object_shortcut 
 9182   
 9183   
 9184 -def fl_create_generic_button(objclass, buttontype, x, y, w, h, label): 
 9185      """ 
 9186          fl_create_generic_button(objclass, buttontype, x, y, w, h, label) -> pObject 
 9187   
 9188          Creates a generic button object. 
 9189   
 9190          @param objclass : value of a new button class 
 9191          @param buttontype : type of button object to be created 
 9192          @param x : horizontal position of button (upper-left corner) 
 9193          @param x : vertical position of button (upper-left corner) 
 9194          @param w : width of button in pixels 
 9195          @param h : height of button in pixels 
 9196          @param label : text label of button 
 9197      """ 
 9198   
 9199      _fl_create_generic_button = cfuncproto( 
 9200              load_so_libforms(), "fl_create_generic_button", 
 9201              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 
 9202              FL_Coord, FL_Coord, STRING], 
 9203              """FL_OBJECT * fl_create_generic_button(int objclass, int type, 
 9204                 FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 
 9205                 const char * label) 
 9206              """) 
 9207      check_admitted_listvalues(buttontype, BUTTONTYPE_list) 
 9208      iobjclass = convert_to_int(objclass) 
 9209      ibuttontype = convert_to_int(buttontype) 
 9210      ix = convert_to_FL_Coord(x) 
 9211      iy = convert_to_FL_Coord(y) 
 9212      iw = convert_to_FL_Coord(w) 
 9213      ih = convert_to_FL_Coord(h) 
 9214      slabel = convert_to_string(label) 
 9215      keep_elem_refs(objclass, buttontype, x, y, w, h, label, iobjclass, 
 9216                     ibuttontype, ix, iy, iw, ih, slabel) 
 9217      retval = _fl_create_generic_button(iobjclass, ibuttontype, ix, iy, 
 9218                                         iw, ih, slabel) 
 9219      return retval 
 9220   
 9221   
 9222  FL_DrawButton = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT)) 
 9223  FL_CleanupButton = cty.CFUNCTYPE(None, cty.POINTER(FL_BUTTON_SPEC)) 
 9224   
 9225  FL_DRAWBUTTON = FL_DrawButton 
 9226  FL_CLEANUPBUTTON = FL_CleanupButton 
 9227   
 9228 -def fl_add_button_class(bclass, py_DrawButton, py_CleanupButton): 
 9229      """ 
 9230          fl_add_button_class(bclass, py_DrawButton, py_CleanupButton) 
 9231   
 9232          Associates a button class with a drawing function. 
 9233   
 9234          @param bclass : value of a new button class 
 9235          @param py_DrawButton : python function to draw button, fn(pObject) 
 9236          @param py_CleanupButton : python function to cleanup button, 
 9237             fn(pButtonSpec) 
 9238      """ 
 9239   
 9240      _fl_add_button_class = cfuncproto( 
 9241              load_so_libforms(), "fl_add_button_class", 
 9242              None, [cty.c_int, FL_DrawButton, FL_CleanupButton], 
 9243              """void fl_add_button_class(int bclass, FL_DrawButton drawit, 
 9244                 FL_CleanupButton cleanup) 
 9245              """) 
 9246      ibclass = convert_to_int(bclass) 
 9247      c_DrawButton = FL_DrawButton(py_DrawButton) 
 9248      c_CleanupButton = FL_CleanupButton(py_CleanupButton) 
 9249      keep_cfunc_refs(c_DrawButton, py_DrawButton, c_CleanupButton, 
 9250         py_CleanupButton) 
 9251      keep_elem_refs(bclass, ibclass) 
 9252      _fl_add_button_class(ibclass, c_DrawButton, c_CleanupButton) 
 9253   
 9254   
 9255 -def fl_set_button_mouse_buttons(pObject, buttons): 
 9256      """ 
 9257          fl_set_button_mouse_buttons(pObject, buttons) 
 9258   
 9259          Function allows to set up to which mouse buttons the button object 
 9260          will react. 
 9261   
 9262          @param pObject : pointer to button object 
 9263          @param buttons : value of mouse buttons to be set 
 9264      """ 
 9265   
 9266      _fl_set_button_mouse_buttons = cfuncproto( 
 9267              load_so_libforms(), "fl_set_button_mouse_buttons", 
 9268              None, [cty.POINTER(FL_OBJECT), cty.c_uint], 
 9269              """void fl_set_button_mouse_buttons(FL_OBJECT * ob, 
 9270                 unsigned int buttons) 
 9271              """) 
 9272      ibuttons = convert_to_int(buttons) 
 9273      keep_elem_refs(pObject, buttons, ibuttons) 
 9274      _fl_set_button_mouse_buttons(pObject, ibuttons) 
 9275   
 9276   
 9277  #def fl_get_button_mouse_buttons(pObject, buttons)       *API change* 
 9278 -def fl_get_button_mouse_buttons(pObject): 
 9279      """ 
 9280          fl_get_button_mouse_buttons(pObject) -> buttons value 
 9281   
 9282          Returns a value indicating which mouse buttons the button object 
 9283          will react to. 
 9284   
 9285          @param pObject : pointer to button object 
 9286      """ 
 9287   
 9288      _fl_get_button_mouse_buttons = cfuncproto( 
 9289              load_so_libforms(), "fl_get_button_mouse_buttons", 
 9290              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], 
 9291              """void fl_get_button_mouse_buttons(FL_OBJECT * ob, 
 9292                 unsigned int * buttons) 
 9293              """) 
 9294      buttons, pbuttons = make_uint_and_pointer() 
 9295      keep_elem_refs(pObject, buttons, pbuttons) 
 9296      _fl_get_button_mouse_buttons(pObject, pbuttons) 
 9297      return buttons 
 9298   
 9299   
 9300  ####################### 
 9301  # forms.h (canvas.h) 
 9302  # Header for FL_CANVAS 
 9303  ####################### 
 9304   
 9305  # Interfaces 
 9306   
 9307 -def fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label): 
 9308      """ 
 9309          fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label) -> pObject 
 9310   
 9311          Creates a generic canvas object. 
 9312   
 9313          @param canvasclass : value of a new canvas class 
 9314          @param canvastype : type of canvas object to be created 
 9315          @param x : horizontal position of canvas (upper-left corner) 
 9316          @param x : vertical position of canvas (upper-left corner) 
 9317          @param w : width of canvas in pixels 
 9318          @param h : height of canvas in pixels 
 9319          @param label : text label of canvas 
 9320      """ 
 9321   
 9322      _fl_create_generic_canvas = cfuncproto( 
 9323              load_so_libforms(), "fl_create_generic_canvas", 
 9324              cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 
 9325              FL_Coord, FL_Coord, STRING], 
 9326              """FL_OBJECT * fl_create_generic_canvas(int canvas_class, 
 9327                 int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 
 9328                 const char * label) 
 9329              """) 
 9330      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9331      icanvasclass = convert_to_int(canvasclass) 
 9332      icanvastype = convert_to_int(canvastype) 
 9333      ix = convert_to_FL_Coord(x) 
 9334      iy = convert_to_FL_Coord(y) 
 9335      iw = convert_to_FL_Coord(w) 
 9336      ih = convert_to_FL_Coord(h) 
 9337      slabel = convert_to_string(label) 
 9338      keep_elem_refs(canvasclass, canvastype, x, y, w, h, label, icanvasclass, 
 9339                     icanvastype, ix, iy, iw, ih, slabel) 
 9340      retval = _fl_create_generic_canvas(icanvasclass, icanvastype, ix, iy, iw, ih, 
 9341                                    slabel) 
 9342      return retval 
 9343   
 9344   
 9345 -def fl_add_canvas(canvastype, x, y, w, h, label): 
 9346      """ 
 9347          fl_add_canvas(canvastype, x, y, w, h, label) -> pObject 
 9348   
 9349          Adds a canvas object. 
 9350   
 9351          @param canvastype : type of canvas object to be added 
 9352          @param x : horizontal position of canvas (upper-left corner) 
 9353          @param x : vertical position of canvas (upper-left corner) 
 9354          @param w : width of canvas in pixels 
 9355          @param h : height of canvas in pixels 
 9356          @param label : text label of canvas 
 9357      """ 
 9358   
 9359      _fl_add_canvas = cfuncproto( 
 9360              load_so_libforms(), "fl_add_canvas", 
 9361              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9362              FL_Coord, STRING], 
 9363              """FL_OBJECT * fl_add_canvas(int type, FL_Coord x, FL_Coord y, 
 9364                 FL_Coord w, FL_Coord h, const char * label) 
 9365              """) 
 9366      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9367      icanvastype = convert_to_int(canvastype) 
 9368      ix = convert_to_FL_Coord(x) 
 9369      iy = convert_to_FL_Coord(y) 
 9370      iw = convert_to_FL_Coord(w) 
 9371      ih = convert_to_FL_Coord(h) 
 9372      slabel = convert_to_string(label) 
 9373      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9374                     iw, ih, slabel) 
 9375      retval = _fl_add_canvas(icanvastype, ix, iy, iw, ih, slabel) 
 9376      return retval 
 9377   
 9378   
 9379 -def fl_create_canvas(canvastype, x, y, w, h, label): 
 9380      """ 
 9381          fl_create_canvas(canvastype, x, y, w, h, label) -> pObject 
 9382   
 9383          Creates a canvas object. 
 9384   
 9385          @param canvastype : type of canvas object to be created 
 9386          @param x : horizontal position of canvas (upper-left corner) 
 9387          @param x : vertical position of canvas (upper-left corner) 
 9388          @param w : width of canvas in pixels 
 9389          @param h : height of canvas in pixels 
 9390          @param label : text label of canvas 
 9391      """ 
 9392   
 9393      _fl_create_canvas = cfuncproto( 
 9394              load_so_libforms(), "fl_create_canvas", 
 9395              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9396              FL_Coord, STRING], 
 9397              """FL_OBJECT * fl_create_canvas(int type, FL_Coord x, FL_Coord y, 
 9398                 FL_Coord w, FL_Coord h, const char * label) 
 9399              """) 
 9400      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9401      icanvastype = convert_to_int(canvastype) 
 9402      ix = convert_to_FL_Coord(x) 
 9403      iy = convert_to_FL_Coord(y) 
 9404      iw = convert_to_FL_Coord(w) 
 9405      ih = convert_to_FL_Coord(h) 
 9406      slabel = convert_to_string(label) 
 9407      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9408                     iw, ih, slabel) 
 9409      retval = _fl_create_canvas(icanvastype, ix, iy, iw, ih, slabel) 
 9410      return retval 
 9411   
 9412   
 9413  # backward compatibility 
 9414  fl_set_canvas_decoration = fl_set_object_boxtype 
 9415   
 9416   
 9417 -def fl_set_canvas_colormap(pObject, colormap): 
 9418      """ fl_set_canvas_colormap(pObject, colormap) 
 9419      """ 
 9420   
 9421      _fl_set_canvas_colormap = cfuncproto( 
 9422              load_so_libforms(), "fl_set_canvas_colormap", 
 9423              None, [cty.POINTER(FL_OBJECT), Colormap], 
 9424              """void fl_set_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 
 9425              """) 
 9426      ulcolormap = convert_to_ulong(colormap) 
 9427      keep_elem_refs(pObject, colormap, ulcolormap) 
 9428      _fl_set_canvas_colormap(pObject, ulcolormap) 
 9429   
 9430   
 9431 -def fl_set_canvas_visual(pObject, vi): 
 9432      """ fl_set_canvas_visual(pObject, vi) 
 9433      """ 
 9434   
 9435      _fl_set_canvas_visual = cfuncproto( 
 9436              load_so_libforms(), "fl_set_canvas_visual", 
 9437              None, [cty.POINTER(FL_OBJECT), cty.POINTER(Visual)], 
 9438              """void fl_set_canvas_visual(FL_OBJECT * obj, Visual * vi) 
 9439              """) 
 9440      keep_elem_refs(pObject, vi) 
 9441      _fl_set_canvas_visual(pObject, vi) 
 9442   
 9443   
 9444 -def fl_set_canvas_depth(pObject, depth): 
 9445      """ fl_set_canvas_depth(pObject, depth) 
 9446      """ 
 9447   
 9448      _fl_set_canvas_depth = cfuncproto( 
 9449              load_so_libforms(), "fl_set_canvas_depth", 
 9450              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9451              """void fl_set_canvas_depth(FL_OBJECT * obj, int depth) 
 9452              """) 
 9453      idepth = convert_to_int(depth) 
 9454      keep_elem_refs(pObject, depth, idepth) 
 9455      _fl_set_canvas_depth(pObject, idepth) 
 9456   
 9457   
 9458 -def fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes): 
 9459      """ fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes) 
 9460      """ 
 9461   
 9462      _fl_set_canvas_attributes = cfuncproto( 
 9463              load_so_libforms(), "fl_set_canvas_attributes", 
 9464              None, [cty.POINTER(FL_OBJECT), cty.c_uint, 
 9465              cty.POINTER(XSetWindowAttributes)], 
 9466              """void fl_set_canvas_attributes(FL_OBJECT * ob, 
 9467                 unsigned int mask, XSetWindowAttributes * xswa) 
 9468              """) 
 9469      uimask = convert_to_uint(mask) 
 9470      keep_elem_refs(pObject, mask, pXSetWindowAttributes, uimask) 
 9471      _fl_set_canvas_attributes(pObject, uimask, pXSetWindowAttributes) 
 9472   
 9473   
 9474  FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), Window, 
 9475              cty.c_int, cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 
 9476   
 9477 -def fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata): 
 9478      """ fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata) -> canvas handler 
 9479      """ 
 9480   
 9481      _fl_add_canvas_handler = cfuncproto( 
 9482              load_so_libforms(), "fl_add_canvas_handler", 
 9483              FL_HANDLE_CANVAS, [cty.POINTER(FL_OBJECT), cty.c_int, 
 9484              FL_HANDLE_CANVAS, cty.c_void_p], 
 9485              """FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT * ob, int ev, 
 9486                 FL_HANDLE_CANVAS h, void * udata) 
 9487              """) 
 9488      iev = convert_to_int(ev) 
 9489      c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 
 9490      pudata = cty.cast(udata, cty.c_void_p) 
 9491      keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 
 9492      keep_elem_refs(pObject, ev, udata, iev, pudata) 
 9493      retval = _fl_add_canvas_handler(pObject, iev, c_HandleCanvas, pudata) 
 9494      return retval 
 9495   
 9496   
 9497 -def fl_get_canvas_id(pObject): 
 9498      """ 
 9499          fl_get_canvas_id(pObject) -> window 
 9500   
 9501          Returns the window ID of the canvas window. 
 9502   
 9503          @param pObject : pointer to canvas object 
 9504      """ 
 9505   
 9506      _fl_get_canvas_id = cfuncproto( 
 9507              load_so_libforms(), "fl_get_canvas_id", 
 9508              Window, [cty.POINTER(FL_OBJECT)], 
 9509              """Window fl_get_canvas_id(FL_OBJECT * ob) 
 9510              """) 
 9511      keep_elem_refs(pObject) 
 9512      retval = _fl_get_canvas_id(pObject) 
 9513      return retval 
 9514   
 9515   
 9516 -def fl_get_canvas_colormap(pObject): 
 9517      """ fl_get_canvas_colormap(pObject) -> colormap 
 9518      """ 
 9519   
 9520      _fl_get_canvas_colormap = cfuncproto( 
 9521              load_so_libforms(), "fl_get_canvas_colormap", 
 9522              Colormap, [cty.POINTER(FL_OBJECT)], 
 9523              """Colormap fl_get_canvas_colormap(FL_OBJECT * ob) 
 9524              """) 
 9525      keep_elem_refs(pObject) 
 9526      retval = _fl_get_canvas_colormap(pObject) 
 9527      return retval 
 9528   
 9529   
 9530 -def fl_get_canvas_depth(pObject): 
 9531      """ fl_get_canvas_depth(pObject) -> depth num. 
 9532      """ 
 9533   
 9534      _fl_get_canvas_depth = cfuncproto( 
 9535              load_so_libforms(), "fl_get_canvas_depth", 
 9536              cty.c_int, [cty.POINTER(FL_OBJECT)], 
 9537              """int fl_get_canvas_depth(FL_OBJECT * obj) 
 9538              """) 
 9539      keep_elem_refs(pObject) 
 9540      retval = _fl_get_canvas_depth(pObject) 
 9541      return retval 
 9542   
 9543   
 9544 -def fl_remove_canvas_handler(pObject, ev, py_HandleCanvas): 
 9545      """ 
 9546          fl_remove_canvas_handler(pObject, ev, py_HandleCanvas) 
 9547   
 9548          Remove a particular handler for event ev. If ev is invalid, removes 
 9549          all handlers and their corresponding event mask. 
 9550   
 9551          @param pObject : pointer to canvas object 
 9552          @param ev : event number 
 9553          @param py_HandleCanvas : python function for canvas handler 
 9554      """ 
 9555   
 9556      _fl_remove_canvas_handler = cfuncproto( 
 9557              load_so_libforms(), "fl_remove_canvas_handler", 
 9558              None, [cty.POINTER(FL_OBJECT), cty.c_int, FL_HANDLE_CANVAS], 
 9559              """void fl_remove_canvas_handler(FL_OBJECT * ob, int ev, 
 9560                 FL_HANDLE_CANVAS h) 
 9561              """) 
 9562      iev = convert_to_int(ev) 
 9563      c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 
 9564      keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 
 9565      keep_elem_refs(pObject, ev, iev) 
 9566      _fl_remove_canvas_handler(pObject, iev, c_HandleCanvas) 
 9567   
 9568   
 9569 -def fl_hide_canvas(pObject): 
 9570      """ 
 9571          fl_hide_canvas(pObject) 
 9572   
 9573          Hides a canvas object. 
 9574   
 9575          @param pObject : pointer to canvas object 
 9576      """ 
 9577   
 9578      _fl_hide_canvas = cfuncproto( 
 9579              load_so_libforms(), "fl_hide_canvas", 
 9580              None, [cty.POINTER(FL_OBJECT)], 
 9581              """void fl_hide_canvas(FL_OBJECT * ob) 
 9582              """) 
 9583      keep_elem_refs(pObject) 
 9584      _fl_hide_canvas(pObject) 
 9585   
 9586   
 9587 -def fl_share_canvas_colormap(pObject, colormap): 
 9588      """ fl_share_canvas_colormap(pObject, colormap) 
 9589      """ 
 9590   
 9591      _fl_share_canvas_colormap = cfuncproto( 
 9592              load_so_libforms(), "fl_share_canvas_colormap", 
 9593              None, [cty.POINTER(FL_OBJECT), Colormap], 
 9594              """void fl_share_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 
 9595              """) 
 9596      ulcolormap = convert_to_ulong(colormap) 
 9597      keep_elem_refs(pObject, colormap, ulcolormap) 
 9598      _fl_share_canvas_colormap(pObject, ulcolormap) 
 9599   
 9600   
 9601 -def fl_clear_canvas(pObject): 
 9602      """ 
 9603          fl_clear_canvas(pObject) 
 9604   
 9605          Clears the canvas to the background color. If no background is 
 9606          defined use black. 
 9607   
 9608          @param pObject : pointer to canvas object 
 9609      """ 
 9610   
 9611      _fl_clear_canvas = cfuncproto( 
 9612              load_so_libforms(), "fl_clear_canvas", 
 9613              None, [cty.POINTER(FL_OBJECT)], 
 9614              """void fl_clear_canvas(FL_OBJECT * ob) 
 9615              """) 
 9616      keep_elem_refs(pObject) 
 9617      _fl_clear_canvas(pObject) 
 9618   
 9619   
 9620  FL_MODIFY_CANVAS_PROP = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT)) 
 9621   
 9622 -def fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 
 9623       py_activateModifyCanvasProp, py_cleanupModifyCanvasProp): 
 9624      """ 
 9625          fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 
 9626          py_activateModifyCanvasProp, py_cleanupModifyCanvasProp) 
 9627   
 9628      """ 
 9629   
 9630      _fl_modify_canvas_prop = cfuncproto( 
 9631              load_so_libforms(), "fl_modify_canvas_prop", 
 9632              None, [cty.POINTER(FL_OBJECT), FL_MODIFY_CANVAS_PROP, 
 9633              FL_MODIFY_CANVAS_PROP, FL_MODIFY_CANVAS_PROP], 
 9634              """void fl_modify_canvas_prop(FL_OBJECT * obj, 
 9635                 FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate, 
 9636                 FL_MODIFY_CANVAS_PROP cleanup) 
 9637              """) 
 9638      c_initModifyCanvasProp = FL_MODIFY_CANVAS_PROP(py_initModifyCanvasProp) 
 9639      c_activateModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 
 9640                  py_activateModifyCanvasProp) 
 9641      c_cleanupModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 
 9642                  py_cleanupModifyCanvasProp) 
 9643      keep_cfunc_refs(c_initModifyCanvasProp, py_initModifyCanvasProp, \ 
 9644                  c_activateModifyCanvasProp, py_activateModifyCanvasProp, \ 
 9645                  c_cleanupModifyCanvasProp, py_cleanupModifyCanvasProp) 
 9646      keep_elem_refs(pObject) 
 9647      _fl_modify_canvas_prop(pObject, c_initModifyCanvasProp, 
 9648                      c_activateModifyCanvasProp, c_cleanupModifyCanvasProp) 
 9649   
 9650   
 9651 -def fl_canvas_yield_to_shortcut(pObject, yes): 
 9652      """ fl_canvas_yield_to_shortcut(pObject, yes) 
 9653      """ 
 9654   
 9655      _fl_canvas_yield_to_shortcut = cfuncproto( 
 9656              load_so_libforms(), "fl_canvas_yield_to_shortcut", 
 9657              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9658              """void fl_canvas_yield_to_shortcut(FL_OBJECT * ob, int yes) 
 9659              """) 
 9660      iyes = convert_to_int(yes) 
 9661      keep_elem_refs(pObject, yes, iyes) 
 9662      _fl_canvas_yield_to_shortcut(pObject, iyes) 
 9663   
 9664   
 9665   
 9666  ############# 
 9667  # glcanvas.h 
 9668  ############# 
 9669   
 9670  # This is an attempt to maintain some sort of backwards compatibility 
 9671  # with old code whilst also getting rid of the old, system-specific 
 9672  # hack. 
 9673   
 9674  # OpenGL canvases 
 9675   
 9676 -def fl_create_glcanvas(canvastype, x, y, w, h, label): 
 9677      """ fl_create_glcanvas(canvastype, x, y, w, h, label) -> pObject 
 9678      """ 
 9679   
 9680      _fl_create_glcanvas = cfuncproto( 
 9681              load_so_libformsgl(), "fl_create_glcanvas", 
 9682              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9683              FL_Coord, STRING], 
 9684              """FL_OBJECT * fl_create_glcanvas(int type, FL_Coord x, FL_Coord y, 
 9685                 FL_Coord w, FL_Coord h, const char * label) 
 9686              """) 
 9687      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9688      icanvastype = convert_to_int(canvastype) 
 9689      ix = convert_to_FL_Coord(x) 
 9690      iy = convert_to_FL_Coord(y) 
 9691      iw = convert_to_FL_Coord(w) 
 9692      ih = convert_to_FL_Coord(h) 
 9693      slabel = convert_to_string(label) 
 9694      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9695                     iw, ih, slabel) 
 9696      retval = _fl_create_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 
 9697      return retval 
 9698   
 9699   
 9700 -def fl_add_glcanvas(canvastype, x, y, w, h, label): 
 9701      """ fl_add_glcanvas(canvastype, x, y, w, h, label) -> pObject 
 9702      """ 
 9703   
 9704      _fl_add_glcanvas = cfuncproto( 
 9705              load_so_libformsgl(), "fl_add_glcanvas", 
 9706              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9707              FL_Coord, STRING], 
 9708              """FL_OBJECT * fl_add_glcanvas(int type, FL_Coord x, FL_Coord y, 
 9709                 FL_Coord w, FL_Coord h, const char * label) 
 9710              """) 
 9711      check_admitted_listvalues(canvastype, CANVASTYPE_list) 
 9712      icanvastype = convert_to_int(canvastype) 
 9713      ix = convert_to_FL_Coord(x) 
 9714      iy = convert_to_FL_Coord(y) 
 9715      iw = convert_to_FL_Coord(w) 
 9716      ih = convert_to_FL_Coord(h) 
 9717      slabel = convert_to_string(label) 
 9718      keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 
 9719                     iw, ih, slabel) 
 9720      retval = _fl_add_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 
 9721      return retval 
 9722   
 9723   
 9724 -def fl_set_glcanvas_defaults(config): 
 9725      """ fl_set_glcanvas_defaults(config): 
 9726      """ 
 9727   
 9728      _fl_set_glcanvas_defaults = cfuncproto( 
 9729              load_so_libformsgl(), "fl_set_glcanvas_defaults", 
 9730              None, [cty.POINTER(cty.c_int)], 
 9731              """void fl_set_glcanvas_defaults(const int * config): 
 9732              """) 
 9733      #iconfig = convert_to_int(config) 
 9734      keep_elem_refs(config)  #, iconfig) 
 9735      _fl_set_glcanvas_defaults(config) 
 9736   
 9737   
 9738 -def fl_get_glcanvas_defaults(config): 
 9739      """ fl_get_glcanvas_defaults(config): 
 9740      """ 
 9741   
 9742      _fl_get_glcanvas_defaults = cfuncproto( 
 9743              load_so_libformsgl(), "fl_get_glcanvas_defaults", 
 9744              None, [cty.c_int], 
 9745              """void fl_get_glcanvas_defaults(int config[ ]): 
 9746              """) 
 9747      iconfig = convert_to_int(config) 
 9748      keep_elem_refs(config, iconfig) 
 9749      _fl_get_glcanvas_defaults(iconfig) 
 9750   
 9751   
 9752 -def fl_set_glcanvas_attributes(pObject, config): 
 9753      """ fl_set_glcanvas_attributes(pObject, config) 
 9754      """ 
 9755   
 9756      _fl_set_glcanvas_attributes = cfuncproto( 
 9757              load_so_libformsgl(), "fl_set_glcanvas_attributes", 
 9758              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 
 9759              """void fl_set_glcanvas_attributes(FL_OBJECT * ob, 
 9760                 const int * config) 
 9761              """) 
 9762      keep_elem_refs(pObject, config) 
 9763      _fl_set_glcanvas_attributes(pObject, config) 
 9764   
 9765   
 9766 -def fl_get_glcanvas_attributes(pObject, attributes): 
 9767      """ fl_get_glcanvas_attributes(pObject, attributes) 
 9768      """ 
 9769   
 9770      _fl_get_glcanvas_attributes = cfuncproto( 
 9771              load_so_libformsgl(), "fl_get_glcanvas_attributes", 
 9772              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 
 9773              """void fl_get_glcanvas_attributes(FL_OBJECT * ob, 
 9774                 int * attributes) 
 9775              """) 
 9776      keep_elem_refs(pObject, attributes) 
 9777      _fl_get_glcanvas_attributes(pObject, attributes) 
 9778   
 9779   
 9780 -def fl_set_glcanvas_direct(pObject, direct): 
 9781      """ fl_set_glcanvas_direct(pObject, direct) 
 9782      """ 
 9783   
 9784      _fl_set_glcanvas_direct = cfuncproto( 
 9785              load_so_libformsgl(), "fl_set_glcanvas_direct", 
 9786              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
 9787              """void fl_set_glcanvas_direct(FL_OBJECT * ob, int direct) 
 9788              """) 
 9789      idirect = convert_to_int(direct) 
 9790      keep_elem_refs(pObject, direct, idirect) 
 9791      _fl_set_glcanvas_direct(pObject, idirect) 
 9792   
 9793   
 9794 -def fl_activate_glcanvas(pObject): 
 9795      """ fl_activate_glcanvas(pObject) 
 9796      """ 
 9797   
 9798      _fl_activate_glcanvas = cfuncproto( 
 9799              load_so_libformsgl(), "fl_activate_glcanvas", 
 9800              None, [cty.POINTER(FL_OBJECT)], 
 9801              """void fl_activate_glcanvas(FL_OBJECT * ob) 
 9802              """) 
 9803      keep_elem_refs(pObject) 
 9804      _fl_activate_glcanvas(pObject) 
 9805   
 9806   
 9807 -def fl_get_glcanvas_xvisualinfo(pObject): 
 9808      """ fl_get_glcanvas_xvisualinfo(pObject) -> xvisualinfo class 
 9809      """ 
 9810   
 9811      _fl_get_glcanvas_xvisualinfo = cfuncproto( 
 9812              load_so_libformsgl(), "fl_get_glcanvas_xvisualinfo", 
 9813              cty.POINTER(XVisualInfo), [cty.POINTER(FL_OBJECT)], 
 9814              """)XVisualInfo * fl_get_glcanvas_xvisualinfo(FL_OBJECT * ob) 
 9815              """) 
 9816      keep_elem_refs(pObject) 
 9817      retval = _fl_get_glcanvas_xvisualinfo(pObject) 
 9818      return retval 
 9819   
 9820   
 9821 -def fl_get_glcanvas_context(pObject): 
 9822      """ fl_get_glcanvas_context(pObject) -> glxcontext class 
 9823      """ 
 9824   
 9825      _fl_get_glcanvas_context = cfuncproto( 
 9826              load_so_libformsgl(), "fl_get_glcanvas_context", 
 9827              GLXContext, [cty.POINTER(FL_OBJECT)], 
 9828              """)GLXContext fl_get_glcanvas_context(FL_OBJECT * ob) 
 9829              """) 
 9830      keep_elem_refs(pObject) 
 9831      retval = _fl_get_glcanvas_context(pObject) 
 9832      return retval 
 9833   
 9834   
 9835 -def fl_glwincreate(config, pGLXContext, w, h): 
 9836      """ fl_glwincreate(config, pGLXContext, w, h) -> window 
 9837      """ 
 9838   
 9839      _fl_glwincreate = cfuncproto( 
 9840              load_so_libformsgl(), "fl_glwincreate", 
 9841              Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 
 9842              cty.c_int, cty.c_int], 
 9843              """Window fl_glwincreate(int * config, GLXContext * context, 
 9844                 int w, int h) 
 9845              """) 
 9846      iw = convert_to_int(w) 
 9847      ih = convert_to_int(h) 
 9848      keep_elem_refs(config, pGLXContext, w, h, iw, ih) 
 9849      retval = _fl_glwincreate(config, pGLXContext, iw, ih) 
 9850      return retval 
 9851   
 9852   
 9853 -def fl_glwinopen(config, pGLXContext, w, h): 
 9854      """ fl_glwinopen(config, pGLXContext, w, h) -> window 
 9855      """ 
 9856   
 9857      _fl_glwinopen = cfuncproto( 
 9858              load_so_libformsgl(), "fl_glwinopen", 
 9859              Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 
 9860              cty.c_int, cty.c_int], 
 9861              """Window fl_glwinopen(int * config, GLXContext * context, 
 9862                 int w, int h 
 9863              """) 
 9864      iw = convert_to_int(w) 
 9865      ih = convert_to_int(h) 
 9866      keep_elem_refs(config, pGLXContext, w, h, iw, ih) 
 9867      retval = _fl_glwinopen(config, pGLXContext, iw, ih) 
 9868      return retval 
 9869   
 9870   
 9871   
 9872  ############################# 
 9873  # forms.h (chart.h) 
 9874  # Object Class: Chart 
 9875  ############################# 
 9876   
 9877  # Routines 
 9878   
 9879 -def fl_create_chart(charttype, x, y, w, h, label): 
 9880      """ 
 9881          fl_create_chart(charttype, x, y, w, h, label) -> pObject 
 9882   
 9883          Creates a chart object. 
 9884   
 9885          @param charttype : type of chart object to be created 
 9886          @param x : horizontal position of chart (upper-left corner) 
 9887          @param x : vertical position of chart (upper-left corner) 
 9888          @param w : width of chart in pixels 
 9889          @param h : height of chart in pixels 
 9890          @param label : text label of chart 
 9891      """ 
 9892   
 9893      _fl_create_chart = cfuncproto( 
 9894              load_so_libforms(), "fl_create_chart", 
 9895              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9896              FL_Coord, STRING], 
 9897              """FL_OBJECT * fl_create_chart(int type, FL_Coord x, FL_Coord y, 
 9898                 FL_Coord w, FL_Coord h, const char * label) 
 9899              """) 
 9900      check_admitted_listvalues(charttype, CHARTTYPE_list) 
 9901      icharttype = convert_to_int(charttype) 
 9902      ix = convert_to_FL_Coord(x) 
 9903      iy = convert_to_FL_Coord(y) 
 9904      iw = convert_to_FL_Coord(w) 
 9905      ih = convert_to_FL_Coord(h) 
 9906      slabel = convert_to_string(label) 
 9907      keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 
 9908                     iw, ih, slabel) 
 9909      retval = _fl_create_chart(icharttype, ix, iy, iw, ih, slabel) 
 9910      return retval 
 9911   
 9912   
 9913 -def fl_add_chart(charttype, x, y, w, h, label): 
 9914      """ 
 9915          fl_add_chart(charttype, x, y, w, h, label) -> pObject 
 9916   
 9917          Adds a chart object. 
 9918   
 9919          @param charttype : type of chart object to be created 
 9920          @param x : horizontal position of chart (upper-left corner) 
 9921          @param x : vertical position of chart (upper-left corner) 
 9922          @param w : width of chart in pixels 
 9923          @param h : height of chart in pixels 
 9924          @param label : text label of chart 
 9925      """ 
 9926   
 9927      _fl_add_chart = cfuncproto( 
 9928              load_so_libforms(), "fl_add_chart", 
 9929              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
 9930              FL_Coord, STRING], 
 9931              """FL_OBJECT * fl_add_chart(int type, FL_Coord x, FL_Coord y, 
 9932                 FL_Coord w, FL_Coord h, const char * label) 
 9933              """) 
 9934      check_admitted_listvalues(charttype, CHARTTYPE_list) 
 9935      icharttype = convert_to_int(charttype) 
 9936      ix = convert_to_FL_Coord(x) 
 9937      iy = convert_to_FL_Coord(y) 
 9938      iw = convert_to_FL_Coord(w) 
 9939      ih = convert_to_FL_Coord(h) 
 9940      slabel = convert_to_string(label) 
 9941      keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 
 9942                     iw, ih, slabel) 
 9943      retval = _fl_add_chart(icharttype, ix, iy, iw, ih, slabel) 
 9944      return retval 
 9945   
 9946   
 9947 -def fl_clear_chart(pObject): 
 9948      """ fl_clear_chart(pObject) 
 9949   
 9950          Clears the contents of a chart. 
 9951   
 9952          @param pObject : pointer to chart object 
 9953      """ 
 9954   
 9955      _fl_clear_chart = cfuncproto( 
 9956              load_so_libforms(), "fl_clear_chart", 
 9957              None, [cty.POINTER(FL_OBJECT)], 
 9958              """void fl_clear_chart(FL_OBJECT * ob) 
 9959              """) 
 9960      keep_elem_refs(pObject) 
 9961      _fl_clear_chart(pObject) 
 9962   
 9963   
 9964 -def fl_add_chart_value(pObject, val, label, col): 
 9965      """ 
 9966          fl_add_chart_value(pObject, val, label, col) 
 9967   
 9968          Adds an item to the chart. 
 9969   
 9970          @param pObject : pointer to chart object 
 9971          @param val : value of chart item 
 9972          @param label : text label of chart object 
 9973          @param col : ? 
 9974      """ 
 9975   
 9976      _fl_add_chart_value = cfuncproto( 
 9977              load_so_libforms(), "fl_add_chart_value", 
 9978              None, [cty.POINTER(FL_OBJECT), cty.c_double, STRING, cty.c_int], 
 9979              """void fl_add_chart_value(FL_OBJECT * ob, double val, 
 9980                 const char * str, int col) 
 9981              """) 
 9982      fval = convert_to_double(val) 
 9983      slabel = convert_to_string(label) 
 9984      icol = convert_to_int(col) 
 9985      keep_elem_refs(pObject, val, label, col, fval, slabel, icol) 
 9986      _fl_add_chart_value(pObject, fval, slabel, icol) 
 9987   
 9988   
 9989 -def fl_insert_chart_value(pObject, indx, val, label, col): 
 9990      """ 
 9991          fl_insert_chart_value(pObject, indx, val, label, col) 
 9992   
 9993          Inserts an item before indx to the chart. 
 9994   
 9995          @param pObject : pointer to chart object 
 9996          @param indx : index position of previous item 
 9997          @param val : value of chart item 
 9998          @param label : text label of chart 
 9999          @param col : ? 
10000      """ 
10001   
10002      _fl_insert_chart_value = cfuncproto( 
10003              load_so_libforms(), "fl_insert_chart_value", 
10004              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 
10005              cty.c_int], 
10006              """void fl_insert_chart_value(FL_OBJECT * ob, int indx, 
10007                 double val, const char * str, int col) 
10008              """) 
10009      iindx = convert_to_int(indx) 
10010      fval = convert_to_double(val) 
10011      slabel = convert_to_string(label) 
10012      icol = convert_to_int(col) 
10013      keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 
10014                     slabel, icol) 
10015      _fl_insert_chart_value(pObject, iindx, fval, slabel, icol) 
10016   
10017   
10018 -def fl_replace_chart_value(pObject, indx, val, label, col): 
10019      """ 
10020          fl_replace_chart_value(pObject, indx, val, label, col) 
10021   
10022          Replaces value in the chart. 
10023   
10024          @param pObject : pointer to chart object 
10025          @param indx : index position of item to be replaced 
10026          @param val : value of chart item 
10027          @param label : text label of chart 
10028          @param col : ? 
10029      """ 
10030   
10031      _fl_replace_chart_value = cfuncproto( 
10032              load_so_libforms(), "fl_replace_chart_value", 
10033              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 
10034              cty.c_int], 
10035              """void fl_replace_chart_value(FL_OBJECT * ob, int indx, 
10036                 double val, const char * str, int col) 
10037              """) 
10038      iindx = convert_to_int(indx) 
10039      fval = convert_to_double(val) 
10040      slabel = convert_to_string(label) 
10041      icol = convert_to_int(col) 
10042      keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 
10043                     slabel, icol) 
10044      _fl_replace_chart_value(pObject, iindx, fval, slabel, icol) 
10045   
10046   
10047 -def fl_set_chart_bounds(pObject, minbound, maxbound): 
10048      """ 
10049          fl_set_chart_bounds(pObject, minbound, maxbound) 
10050   
10051          Sets the boundaries/limits for values of a chart object. 
10052   
10053          @param pObject : pointer to chart object 
10054          @param minbound : minimum bounds to be set 
10055          @param maxbound : maximum bounds to be set 
10056      """ 
10057   
10058      _fl_set_chart_bounds = cfuncproto( 
10059              load_so_libforms(), "fl_set_chart_bounds", 
10060              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10061              """void fl_set_chart_bounds(FL_OBJECT * ob, double min, 
10062                 double max) 
10063              """) 
10064      fminbound = convert_to_double(minbound) 
10065      fmaxbound = convert_to_double(maxbound) 
10066      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
10067      _fl_set_chart_bounds(pObject, fminbound, fmaxbound) 
10068   
10069   
10070  #def fl_get_chart_bounds(pObject, minbound, maxbound)       *API change* 
10071 -def fl_get_chart_bounds(pObject): 
10072      """ 
10073          fl_get_chart_bounds(pObject) -> minbound, maxbound 
10074   
10075          Returns the boundaries/limits set for values of a chart object. 
10076   
10077          @param pObject : pointer to chart object 
10078      """ 
10079   
10080      _fl_get_chart_bounds = cfuncproto( 
10081              load_so_libforms(), "fl_get_chart_bounds", 
10082              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10083              cty.POINTER(cty.c_double)], 
10084              """void fl_get_chart_bounds(FL_OBJECT * ob, double * min, 
10085                 double * max) 
10086              """) 
10087      minbound, pminbound = make_double_and_pointer() 
10088      maxbound, pmaxbound = make_double_and_pointer() 
10089      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
10090      _fl_get_chart_bounds(pObject, pminbound, pmaxbound) 
10091      return minbound, maxbound 
10092   
10093   
10094 -def fl_set_chart_maxnumb(pObject, maxnum): 
10095      """ 
10096          fl_set_chart_maxnumb(pObject, maxnum) 
10097   
10098          Sets the maximum number of values displayed in the chart. 
10099   
10100          @param pObject : pointer to chart object 
10101          @param maxnum : maximum number of values to display 
10102      """ 
10103   
10104      _fl_set_chart_maxnumb = cfuncproto( 
10105              load_so_libforms(), "fl_set_chart_maxnumb", 
10106              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10107              """void fl_set_chart_maxnumb(FL_OBJECT * ob, int maxnumb) 
10108              """) 
10109      imaxnum = convert_to_int(maxnum) 
10110      keep_elem_refs(pObject, maxnum, imaxnum) 
10111      _fl_set_chart_maxnumb(pObject, imaxnum) 
10112   
10113   
10114 -def fl_set_chart_autosize(pObject, autosize): 
10115      """ 
10116          fl_set_chart_autosize(pObject, autosize) 
10117   
10118          Sets whether the chart should autosize along the x-axis. 
10119   
10120          @param pObject : pointer to chart object 
10121          @param autosize : autosize flag is enabled/disabled (1|0) 
10122      """ 
10123   
10124      _fl_set_chart_autosize = cfuncproto( 
10125              load_so_libforms(), "fl_set_chart_autosize", 
10126              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10127              """void fl_set_chart_autosize(FL_OBJECT * ob, int autosize) 
10128              """) 
10129      iautosize = convert_to_int(autosize) 
10130      keep_elem_refs(pObject, autosize, iautosize) 
10131      _fl_set_chart_autosize(pObject, iautosize) 
10132   
10133   
10134 -def fl_set_chart_lstyle(pObject, lstyle): 
10135      """ fl_set_chart_lstyle(pObject, lstyle) 
10136      """ 
10137   
10138      _fl_set_chart_lstyle = cfuncproto( 
10139              load_so_libforms(), "fl_set_chart_lstyle", 
10140              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10141              """void fl_set_chart_lstyle(FL_OBJECT * ob, int lstyle) 
10142              """) 
10143      ilstyle = convert_to_int(lstyle) 
10144      keep_elem_refs(pObject, lstyle, ilstyle) 
10145      _fl_set_chart_lstyle(pObject, ilstyle) 
10146   
10147   
10148 -def fl_set_chart_lsize(pObject, lsize): 
10149      """ fl_set_chart_lsize(pObject, lsize) 
10150      """ 
10151   
10152      _fl_set_chart_lsize = cfuncproto( 
10153              load_so_libforms(), "fl_set_chart_lsize", 
10154              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10155              """void fl_set_chart_lsize(FL_OBJECT * ob, int lsize) 
10156              """) 
10157      ilsize = convert_to_int(lsize) 
10158      keep_elem_refs(pObject, lsize, ilsize) 
10159      _fl_set_chart_lsize(pObject, ilsize) 
10160   
10161   
10162 -def fl_set_chart_lcolor(pObject, colr): 
10163      """ fl_set_chart_lcolor(pObject, colr) 
10164      """ 
10165   
10166      _fl_set_chart_lcolor = cfuncproto( 
10167              load_so_libforms(), "fl_set_chart_lcolor", 
10168              None, [cty.POINTER(FL_OBJECT), FL_COLOR], 
10169              """void fl_set_chart_lcolor(FL_OBJECT * ob, FL_COLOR lcol) 
10170              """) 
10171      ulcolr = convert_to_FL_COLOR(colr) 
10172      keep_elem_refs(pObject, colr, ulcolr) 
10173      _fl_set_chart_lcolor(pObject, ulcolr) 
10174   
10175   
10176 -def fl_set_chart_baseline(pObject, yesno): 
10177      """ fl_set_chart_baseline(pObject, yesno) 
10178      """ 
10179   
10180      _fl_set_chart_baseline = cfuncproto( 
10181              load_so_libforms(), "fl_set_chart_baseline", 
10182              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10183              """void fl_set_chart_baseline(FL_OBJECT * ob, int iYesNo) 
10184              """) 
10185      iyesno = convert_to_int(yesno) 
10186      keep_elem_refs(pObject, yesno, iyesno) 
10187      _fl_set_chart_baseline(pObject, iyesno) 
10188   
10189   
10190  fl_set_chart_lcol = fl_set_chart_lcolor 
10191   
10192   
10193   
10194  ##################### 
10195  # forms.h (choice.h) 
10196  ##################### 
10197   
10198  # Routines 
10199   
10200 -def fl_create_choice(choicetype, x, y, w, h, label): 
10201      """ 
10202          fl_create_choice(choicetype, x, y, w, h, label) -> pObject 
10203   
10204          Creates a choice object. 
10205   
10206          @param choicetype : type of choice object to be created 
10207          @param x : horizontal position of choice (upper-left corner) 
10208          @param x : vertical position of choice (upper-left corner) 
10209          @param w : width of choice in pixels 
10210          @param h : height of choice in pixels 
10211          @param label : text label of choice 
10212      """ 
10213   
10214      _fl_create_choice = cfuncproto( 
10215              load_so_libforms(), "fl_create_choice", 
10216              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10217              FL_Coord, STRING], 
10218              """FL_OBJECT * fl_create_choice(int type, FL_Coord x, FL_Coord y, 
10219                 FL_Coord w, FL_Coord h, const char * label) 
10220              """) 
10221      check_admitted_listvalues(choicetype, CHOICETYPE_list) 
10222      ichoicetype = convert_to_int(choicetype) 
10223      ix = convert_to_FL_Coord(x) 
10224      iy = convert_to_FL_Coord(y) 
10225      iw = convert_to_FL_Coord(w) 
10226      ih = convert_to_FL_Coord(h) 
10227      slabel = convert_to_string(label) 
10228      keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 
10229                     iw, ih, slabel) 
10230      retval = _fl_create_choice(ichoicetype, ix, iy, iw, ih, slabel) 
10231      return retval 
10232   
10233   
10234 -def fl_add_choice(choicetype, x, y, w, h, label): 
10235      """ 
10236          fl_add_choice(choicetype, x, y, w, h, label) -> pObject 
10237   
10238          Adds a choice object. 
10239   
10240          @param choicetype : type of choice object to be added 
10241          @param x : horizontal position of choice (upper-left corner) 
10242          @param x : vertical position of choice (upper-left corner) 
10243          @param w : width of choice in pixels 
10244          @param h : height of choice in pixels 
10245          @param label : text label of choice 
10246      """ 
10247   
10248      _fl_add_choice = cfuncproto( 
10249              load_so_libforms(), "fl_add_choice", 
10250              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10251              FL_Coord, STRING], 
10252              """FL_OBJECT * fl_add_choice(int type, FL_Coord x, FL_Coord y, 
10253                 FL_Coord w, FL_Coord h, const char * label)  DEPRECATED 
10254              """) 
10255      check_admitted_listvalues(choicetype, CHOICETYPE_list) 
10256      ichoicetype = convert_to_int(choicetype) 
10257      ix = convert_to_FL_Coord(x) 
10258      iy = convert_to_FL_Coord(y) 
10259      iw = convert_to_FL_Coord(w) 
10260      ih = convert_to_FL_Coord(h) 
10261      slabel = convert_to_string(label) 
10262      keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 
10263                     iw, ih, slabel) 
10264      retval = _fl_add_choice(ichoicetype, ix, iy, iw, ih, slabel) 
10265      return retval 
10266   
10267   
10268 -def fl_clear_choice(pObject): 
10269      """ 
10270          fl_clear_choice(pObject) 
10271   
10272          Clears the choice object. 
10273   
10274          @param pObject : pointer to chioce object 
10275      """ 
10276   
10277      _fl_clear_choice = cfuncproto( 
10278              load_so_libforms(), "fl_clear_choice", 
10279              None, [cty.POINTER(FL_OBJECT)], 
10280              """void fl_clear_choice(FL_OBJECT * ob)    DEPRECATED 
10281              """) 
10282      keep_elem_refs(pObject) 
10283      _fl_clear_choice(pObject) 
10284   
10285   
10286 -def fl_addto_choice(pObject, choicetxt): 
10287      """ 
10288          fl_addto_choice(pObject, choicetxt) -> num. 
10289   
10290          Adds a single or multiple (delimited by '|') item(s) to a choice. 
10291   
10292          @param pObject : pointer to choice object 
10293          @param choicetxt : text of item(s) to be added 
10294      """ 
10295   
10296      _fl_addto_choice = cfuncproto( 
10297              load_so_libforms(), "fl_addto_choice", 
10298              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
10299              """int fl_addto_choice(FL_OBJECT * ob, const char * str)    DEPRECATED 
10300              """) 
10301      warn_deprecated_function() 
10302      schoicetxt = convert_to_string(choicetxt) 
10303      keep_elem_refs(pObject, choicetxt, schoicetxt) 
10304      retval = _fl_addto_choice(pObject, schoicetxt) 
10305      return retval 
10306   
10307   
10308 -def fl_replace_choice(pObject, itemnum, choicetxt): 
10309      """ 
10310          fl_replace_choice(pObject, itemnum, choicetxt) 
10311   
10312          Replaces a line to the choice item. 
10313   
10314          @param pObject : pointer to choice object 
10315          @param itemnum : item number to be replaced 
10316          @param choicetxt : text of item to replace 
10317      """ 
10318   
10319      _fl_replace_choice = cfuncproto( 
10320              load_so_libforms(), "fl_replace_choice", 
10321              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
10322              """void fl_replace_choice(FL_OBJECT * ob, int numb, 
10323                 const char * str)    DEPRECATED 
10324              """) 
10325      iitemnum = convert_to_int(itemnum) 
10326      schoicetxt = convert_to_string(choicetxt) 
10327      keep_elem_refs(pObject, itemnum, choicetxt, iitemnum, schoicetxt) 
10328      _fl_replace_choice(pObject, iitemnum, schoicetxt) 
10329   
10330   
10331 -def fl_delete_choice(pObject, itemnum): 
10332      """ 
10333          fl_delete_choice(pObject, itemnum) 
10334   
10335          Removes a line from the choice item. 
10336   
10337          @param pObject : pointer to choice object 
10338          @param itemnum : item number 
10339      """ 
10340   
10341      _fl_delete_choice = cfuncproto( 
10342              load_so_libforms(), "fl_delete_choice", 
10343              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10344              """void fl_delete_choice(FL_OBJECT * ob, int numb)    DEPRECATED 
10345              """) 
10346      iitemnum = convert_to_int(itemnum) 
10347      keep_elem_refs(pObject, itemnum, iitemnum) 
10348      _fl_delete_choice(pObject, iitemnum) 
10349   
10350   
10351 -def fl_set_choice(pObject, choice): 
10352      """ 
10353          fl_set_choice(pObject, choice) 
10354   
10355          Sets the number of the choice. 
10356   
10357          @param pObject : pointer to choice object 
10358          @param choice : choice number 
10359      """ 
10360   
10361      _fl_set_choice = cfuncproto( 
10362              load_so_libforms(), "fl_set_choice", 
10363              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10364              """void fl_set_choice(FL_OBJECT * ob, int choice)    DEPRECATED 
10365              """) 
10366      ichoice = convert_to_int(choice) 
10367      keep_elem_refs(pObject, choice, ichoice) 
10368      _fl_set_choice(pObject, ichoice) 
10369   
10370   
10371 -def fl_set_choice_text(pObject, choicetxt): 
10372      """ 
10373          fl_set_choice_text(pObject, choicetxt) 
10374   
10375          Sets the choice using choice text. 
10376   
10377          @param pObject : pointer to choice object 
10378          @param choicetxt : text of choice 
10379      """ 
10380   
10381      _fl_set_choice_text = cfuncproto( 
10382              load_so_libforms(), "fl_set_choice_text", 
10383              None, [cty.POINTER(FL_OBJECT), STRING], 
10384              """void fl_set_choice_text(FL_OBJECT * ob, const char * txt)    DEPRECATED 
10385              """) 
10386      schoicetxt = convert_to_string(choicetxt) 
10387      keep_elem_refs(pObject, choicetxt, schoicetxt) 
10388      _fl_set_choice_text(pObject, schoicetxt) 
10389   
10390   
10391 -def fl_get_choice(pObject): 
10392      """ 
10393          fl_get_choice(pObject) -> num. 
10394   
10395          Returns the number of the choice. 
10396   
10397          @param pObject : pointer to choice object 
10398      """ 
10399   
10400      _fl_get_choice = cfuncproto( 
10401              load_so_libforms(), "fl_get_choice", 
10402              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10403              """int fl_get_choice(FL_OBJECT * ob)    DEPRECATED 
10404              """) 
10405      keep_elem_refs(pObject) 
10406      retval = _fl_get_choice(pObject) 
10407      return retval 
10408   
10409   
10410 -def fl_get_choice_item_text(pObject, n): 
10411      """ fl_get_choice_item_text(pObject, n) -> text string 
10412      """ 
10413   
10414      _fl_get_choice_item_text = cfuncproto( 
10415              load_so_libforms(), "fl_get_choice_item_text", 
10416              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
10417              """const char * fl_get_choice_item_text(FL_OBJECT * ob, int n)    DEPRECATED 
10418              """) 
10419      inum = convert_to_int(n) 
10420      keep_elem_refs(pObject, n, inum) 
10421      retval = _fl_get_choice_item_text(pObject, inum) 
10422      return retval 
10423   
10424   
10425 -def fl_get_choice_maxitems(pObject): 
10426      """ fl_get_choice_maxitems(pObject) -> items num. 
10427      """ 
10428   
10429      _fl_get_choice_maxitems = cfuncproto( 
10430              load_so_libforms(), "fl_get_choice_maxitems", 
10431              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10432              """int fl_get_choice_maxitems(FL_OBJECT * ob)    DEPRECATED 
10433              """) 
10434      keep_elem_refs(pObject) 
10435      retval = _fl_get_choice_maxitems(pObject) 
10436      return retval 
10437   
10438   
10439 -def fl_get_choice_text(pObject): 
10440      """ 
10441          fl_get_choice_text(pObject) -> text string 
10442   
10443          Returns the text of the choice. 
10444   
10445          @param pObject : pointer to choice object 
10446      """ 
10447   
10448      _fl_get_choice_text = cfuncproto( 
10449              load_so_libforms(), "fl_get_choice_text", 
10450              STRING, [cty.POINTER(FL_OBJECT)], 
10451              """const char * fl_get_choice_text(FL_OBJECT * ob)    DEPRECATED 
10452              """) 
10453      keep_elem_refs(pObject) 
10454      retval = _fl_get_choice_text(pObject) 
10455      return retval 
10456   
10457   
10458 -def fl_set_choice_fontsize(pObject, size): 
10459      """ 
10460          fl_set_choice_fontsize(pObject, size) 
10461   
10462          Sets the font size inside the choice. 
10463   
10464          @param pObject : pointer to choice object 
10465          @param size : font size of choice to be set 
10466      """ 
10467   
10468      _fl_set_choice_fontsize = cfuncproto( 
10469              load_so_libforms(), "fl_set_choice_fontsize", 
10470              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10471              """void fl_set_choice_fontsize(FL_OBJECT * ob, int size) 
10472              """) 
10473      isize = convert_to_int(size) 
10474      keep_elem_refs(pObject, size, isize) 
10475      _fl_set_choice_fontsize(pObject, isize) 
10476   
10477   
10478 -def fl_set_choice_fontstyle(pObject, style): 
10479      """ 
10480          fl_set_choice_fontstyle(pObject, style) 
10481   
10482          Sets the font style inside the choice. 
10483   
10484          @param pObject : pointer to choice object 
10485          @param style : font style of choice to be set 
10486      """ 
10487   
10488      _fl_set_choice_fontstyle = cfuncproto( 
10489              load_so_libforms(), "fl_set_choice_fontstyle", 
10490              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10491              """void fl_set_choice_fontstyle(FL_OBJECT * ob, int style) 
10492              """) 
10493      istyle = convert_to_int(style) 
10494      keep_elem_refs(pObject, style, istyle) 
10495      _fl_set_choice_fontstyle(pObject, istyle) 
10496   
10497   
10498 -def fl_set_choice_align(pObject, align): 
10499      """ 
10500          fl_set_choice_align(pObject, align) 
10501   
10502          Sets alignment of text inside the choice. 
10503   
10504          @param pObject : pointer to choice object 
10505          @param align : alignment of choice text to be set 
10506      """ 
10507   
10508      _fl_set_choice_align = cfuncproto( 
10509              load_so_libforms(), "fl_set_choice_align", 
10510              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10511              """void fl_set_choice_align(FL_OBJECT * ob, int align) 
10512              """) 
10513      ialign = convert_to_int(align) 
10514      keep_elem_refs(pObject, align, ialign) 
10515      _fl_set_choice_align(pObject, ialign) 
10516   
10517   
10518 -def fl_get_choice_item_mode(pObject, item): 
10519      """ fl_get_choice_item_mode(pObject, item) -> mode num. 
10520      """ 
10521   
10522      _fl_get_choice_item_mode = cfuncproto( 
10523              load_so_libforms(), "fl_get_choice_item_mode", 
10524              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
10525              """int fl_get_choice_item_mode(FL_OBJECT * ob, int item)    DEPRECATED 
10526              """) 
10527      iitem = convert_to_int(item) 
10528      keep_elem_refs(pObject, item, iitem) 
10529      retval = _fl_get_choice_item_mode(pObject, iitem) 
10530      return retval 
10531   
10532   
10533 -def fl_set_choice_item_mode(pObject, itemnum, mode): 
10534      """ 
10535          fl_set_choice_item_mode(pObject, itemnum, mode) 
10536   
10537          Sets the mode of an item in a choice object. 
10538   
10539          @param pObject : pointer to choice object 
10540          @param itemnum : item number whose mode is to be set 
10541          @param mode : mode of item 
10542      """ 
10543   
10544      _fl_set_choice_item_mode = cfuncproto( 
10545              load_so_libforms(), "fl_set_choice_item_mode", 
10546              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 
10547              """void fl_set_choice_item_mode(FL_OBJECT * ob, int item, 
10548                 unsigned int mode) 
10549              """) 
10550      iitemnum = convert_to_int(itemnum) 
10551      uimode = convert_to_uint(mode) 
10552      keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 
10553      _fl_set_choice_item_mode(pObject, iitemnum, uimode) 
10554   
10555   
10556 -def fl_set_choice_item_shortcut(pObject, item, sctext): 
10557      """ fl_set_choice_item_shortcut(pObject, item, sstext) 
10558      """ 
10559   
10560      _fl_set_choice_item_shortcut = cfuncproto( 
10561              load_so_libforms(), "fl_set_choice_item_shortcut", 
10562              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
10563              """void fl_set_choice_item_shortcut(FL_OBJECT * ob, int item, 
10564                 const char * sc) 
10565              """) 
10566      iitem = convert_to_int(item) 
10567      ssctext = convert_to_string(sctext) 
10568      keep_elem_refs(pObject, item, sctext, iitem, ssctext) 
10569      _fl_set_choice_item_shortcut(pObject, iitem, ssctext) 
10570   
10571   
10572 -def fl_set_choice_entries(pObject, pPopupEntry): 
10573      """ fl_set_choice_entries(pObject, pPopupEntry) -> num. 
10574      """ 
10575   
10576      _fl_set_choice_entries = cfuncproto( 
10577              load_so_libforms(), "fl_set_choice_entries", 
10578              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 
10579              """int fl_set_choice_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent)    DEPRECATED 
10580              """) 
10581      keep_elem_refs(pObject, pPopupEntry) 
10582      retval = _fl_set_choice_entries(pObject, pPopupEntry) 
10583      return retval 
10584   
10585   
10586 -def fl_set_choice_notitle(pObject, n): 
10587      """ fl_set_choice_notitle(pObject, n) -> num. 
10588      """ 
10589   
10590      _fl_set_choice_notitle = cfuncproto( 
10591              load_so_libforms(), "fl_set_choice_notitle", 
10592              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
10593              """int fl_set_choice_notitle(FL_OBJECT * ob, int n) 
10594              """) 
10595      inum = convert_to_int(n) 
10596      keep_elem_refs(pObject, n, inum) 
10597      retval = _fl_set_choice_notitle(pObject, inum) 
10598      return retval 
10599   
10600   
10601   
10602  ################################# 
10603  # forms.h (clipbd.h) 
10604  # prototypes for clipboard stuff 
10605  ################################# 
10606   
10607  FL_LOSE_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 
10608                                       cty.c_long) 
10609  FL_LOSE_SELECTION_CALLBACK = FL_LOSE_SELECTION_CB 
10610   
10611 -def fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb): 
10612      """ fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb) -> num. 
10613      """ 
10614   
10615      _fl_stuff_clipboard = cfuncproto( 
10616              load_so_libforms(), "fl_stuff_clipboard", 
10617              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, cty.c_void_p, 
10618              cty.c_long, FL_LOSE_SELECTION_CB], 
10619              """int fl_stuff_clipboard(FL_OBJECT * ob, long int type, 
10620                 const char * data, long int size, 
10621                 FL_LOSE_SELECTION_CB lose_callback) 
10622              """) 
10623      lclipbdtype = convert_to_long(clipbdtype)       # type is not used 
10624      lsize = convert_to_long(size) 
10625      c_LoseSelectionCb = FL_LOSE_SELECTION_CB(py_LoseSelectionCb) 
10626      keep_cfunc_refs(c_LoseSelectionCb, py_LoseSelectionCb) 
10627      keep_elem_refs(pObject, clipbdtype, data, size, lclipbdtype, lsize) 
10628      retval = _fl_stuff_clipboard(pObject, lclipbdtype, data, lsize, 
10629                                   c_LoseSelectionCb) 
10630      return retval 
10631   
10632   
10633  FL_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 
10634                                  cty.c_long, cty.c_void_p, cty.c_long) 
10635  FL_SELECTION_CALLBACK = FL_SELECTION_CB 
10636   
10637 -def fl_request_clipboard(pObject, clipbdtype, py_SelectionCb): 
10638      """ fl_request_clipboard(pObject, clipbdtype, py_SelectionCb) -> num. 
10639      """ 
10640   
10641      _fl_request_clipboard = cfuncproto( 
10642              load_so_libforms(), "fl_request_clipboard", 
10643              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, FL_SELECTION_CB], 
10644              """int fl_request_clipboard(FL_OBJECT * ob, long int type, 
10645                 FL_SELECTION_CB got_it_callback) 
10646              """) 
10647      lclipbdtype = convert_to_long(clipbdtype)       # type is not used 
10648      c_SelectionCb = FL_SELECTION_CB(py_SelectionCb) 
10649      keep_cfunc_refs(c_SelectionCb, py_SelectionCb) 
10650      keep_elem_refs(pObject, clipbdtype, lclipbdtype) 
10651      retval = _fl_request_clipboard(pObject, lclipbdtype, c_SelectionCb) 
10652      return retval 
10653   
10654   
10655   
10656  ################################# 
10657  # forms.h (clock.h) 
10658  ################################# 
10659   
10660   
10661 -def fl_create_clock(clocktype, x, y, w, h, label): 
10662      """ 
10663          fl_create_clock(clocktype, x, y, w, h, label) -> pObject 
10664   
10665          Creates a clock object. 
10666   
10667          @param clocktype : type of clock object to be created 
10668          @param x : horizontal position of clock (upper-left corner) 
10669          @param x : vertical position of clock (upper-left corner) 
10670          @param w : width of clock in pixels 
10671          @param h : height of clock in pixels 
10672          @param label : text label of clock 
10673      """ 
10674   
10675      _fl_create_clock = cfuncproto( 
10676              load_so_libforms(), "fl_create_clock", 
10677              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10678              FL_Coord, STRING], 
10679              """FL_OBJECT * fl_create_clock(int type, FL_Coord x, FL_Coord y, 
10680                 FL_Coord w, FL_Coord h, const char * s) 
10681              """) 
10682      check_admitted_listvalues(clocktype, CLOCKTYPE_list) 
10683      iclocktype = convert_to_int(clocktype) 
10684      ix = convert_to_FL_Coord(x) 
10685      iy = convert_to_FL_Coord(y) 
10686      iw = convert_to_FL_Coord(w) 
10687      ih = convert_to_FL_Coord(h) 
10688      slabel = convert_to_string(label) 
10689      keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 
10690                     iw, ih, slabel) 
10691      retval = _fl_create_clock(iclocktype, ix, iy, iw, ih, slabel) 
10692      return retval 
10693   
10694   
10695 -def fl_add_clock(clocktype, x, y, w, h, label): 
10696      """ 
10697          fl_add_clock(clocktype, x, y, w, h, label) -> pObject 
10698   
10699          Adds a clock object. 
10700   
10701          @param clocktype : type of clock object to be added 
10702          @param x : horizontal position of clock (upper-left corner) 
10703          @param x : vertical position of clock (upper-left corner) 
10704          @param w : width of clock in pixels 
10705          @param h : height of clock in pixels 
10706          @param label : text label of clock 
10707      """ 
10708   
10709      _fl_add_clock = cfuncproto( 
10710              load_so_libforms(), "fl_add_clock", 
10711              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10712              FL_Coord, STRING], 
10713              """FL_OBJECT * fl_add_clock(int type, FL_Coord x, FL_Coord y, 
10714                 FL_Coord w, FL_Coord h, const char * s) 
10715              """) 
10716      check_admitted_listvalues(clocktype, CLOCKTYPE_list) 
10717      iclocktype = convert_to_int(clocktype) 
10718      ix = convert_to_FL_Coord(x) 
10719      iy = convert_to_FL_Coord(y) 
10720      iw = convert_to_FL_Coord(w) 
10721      ih = convert_to_FL_Coord(h) 
10722      slabel = convert_to_string(label) 
10723      keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 
10724                     iw, ih, slabel) 
10725      retval = _fl_add_clock(iclocktype, ix, iy, iw, ih, slabel) 
10726      return retval 
10727   
10728   
10729  #def fl_get_clock(pObject, hr, mn, sec)       *API change* 
10730 -def fl_get_clock(pObject): 
10731      """ fl_get_clock(pObject) -> hr, mn, sec 
10732   
10733          Returns time values from a clock object. 
10734   
10735          @param pObject : pointer to clock object 
10736      """ 
10737   
10738      _fl_get_clock = cfuncproto( 
10739              load_so_libforms(), "fl_get_clock", 
10740              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
10741              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
10742              """void fl_get_clock(FL_OBJECT * ob, int * h, int * m, int * s) 
10743              """) 
10744      hr, phr = make_int_and_pointer() 
10745      mn, pmn = make_int_and_pointer() 
10746      sec, psec = make_int_and_pointer() 
10747      keep_elem_refs(pObject, hr, mn, sec, phr, pmn, psec) 
10748      _fl_get_clock(pObject, phr, pmn, psec) 
10749      return hr, mn, sec 
10750   
10751   
10752 -def fl_set_clock_adjustment(pObject, offset): 
10753      """ fl_set_clock_adjustment(pObject, offset) -> num. 
10754      """ 
10755   
10756      _fl_set_clock_adjustment = cfuncproto( 
10757              load_so_libforms(), "fl_set_clock_adjustment", 
10758              cty.c_long, [cty.POINTER(FL_OBJECT), cty.c_long], 
10759              """long int fl_set_clock_adjustment(FL_OBJECT * ob, 
10760                 long int offset) 
10761              """) 
10762      loffset = convert_to_long(offset) 
10763      keep_elem_refs(pObject, offset, loffset) 
10764      retval = _fl_set_clock_adjustment(pObject, loffset) 
10765      return retval 
10766   
10767   
10768 -def fl_set_clock_ampm(pObject, y): 
10769      """ fl_set_clock_ampm(pObject, y) 
10770      """ 
10771   
10772      _fl_set_clock_ampm = cfuncproto( 
10773              load_so_libforms(), "fl_set_clock_ampm", 
10774              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10775              """void fl_set_clock_ampm(FL_OBJECT * ob, int y) 
10776              """) 
10777      iy = convert_to_int(y) 
10778      keep_elem_refs(pObject, y, iy) 
10779      _fl_set_clock_ampm(pObject, iy) 
10780   
10781   
10782   
10783  ###################### 
10784  # forms.h (counter.h) 
10785  ###################### 
10786   
10787  # Routines 
10788   
10789 -def fl_create_counter(countertype, x, y, w, h, label): 
10790      """ 
10791          fl_create_counter(countertype, x, y, w, h, label) -> pObject 
10792   
10793          Creates a counter object. 
10794   
10795          @param countertype : type of counter object to be created 
10796          @param x : horizontal position of counter (upper-left corner) 
10797          @param x : vertical position of counter (upper-left corner) 
10798          @param w : width of counter in pixels 
10799          @param h : height of counter in pixels 
10800          @param label : text label of counter 
10801      """ 
10802   
10803      _fl_create_counter = cfuncproto( 
10804              load_so_libforms(), "fl_create_counter", 
10805              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10806              FL_Coord, STRING], 
10807              """FL_OBJECT * fl_create_counter(int type, FL_Coord x, FL_Coord y, 
10808                 FL_Coord w, FL_Coord h, const char * label) 
10809              """) 
10810      check_admitted_listvalues(countertype, COUNTERTYPE_list) 
10811      icountertype = convert_to_int(countertype) 
10812      ix = convert_to_FL_Coord(x) 
10813      iy = convert_to_FL_Coord(y) 
10814      iw = convert_to_FL_Coord(w) 
10815      ih = convert_to_FL_Coord(h) 
10816      slabel = convert_to_string(label) 
10817      keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 
10818                     iw, ih, slabel) 
10819      retval = _fl_create_counter(icountertype, ix, iy, iw, ih, slabel) 
10820      return retval 
10821   
10822   
10823 -def fl_add_counter(countertype, x, y, w, h, label): 
10824      """ 
10825          fl_add_counter(countertype, x, y, w, h, label) -> pObject 
10826   
10827          Adds a counter object. 
10828   
10829          @param countertype : type of counter object to be added 
10830          @param x : horizontal position of counter (upper-left corner) 
10831          @param x : vertical position of counter (upper-left corner) 
10832          @param w : width of counter in pixels 
10833          @param h : height of counter in pixels 
10834          @param label : text label of counter 
10835      """ 
10836   
10837      _fl_add_counter = cfuncproto( 
10838              load_so_libforms(), "fl_add_counter", 
10839              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
10840              FL_Coord, STRING], 
10841              """FL_OBJECT * fl_add_counter(int type, FL_Coord x, FL_Coord y, 
10842                 FL_Coord w, FL_Coord h, const char * label) 
10843              """) 
10844      check_admitted_listvalues(countertype, COUNTERTYPE_list) 
10845      icountertype = convert_to_int(countertype) 
10846      ix = convert_to_FL_Coord(x) 
10847      iy = convert_to_FL_Coord(y) 
10848      iw = convert_to_FL_Coord(w) 
10849      ih = convert_to_FL_Coord(h) 
10850      slabel = convert_to_string(label) 
10851      keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 
10852                     iw, ih, slabel) 
10853      retval = _fl_add_counter(icountertype, ix, iy, iw, ih, slabel) 
10854      return retval 
10855   
10856   
10857 -def fl_set_counter_value(pObject, val): 
10858      """ fl_set_counter_value(pObject, val) 
10859      """ 
10860   
10861      _fl_set_counter_value = cfuncproto( 
10862              load_so_libforms(), "fl_set_counter_value", 
10863              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
10864              """void fl_set_counter_value(FL_OBJECT * ob, double val) 
10865              """) 
10866      fval = convert_to_double(val) 
10867      keep_elem_refs(pObject, val, fval) 
10868      _fl_set_counter_value(pObject, fval) 
10869   
10870   
10871 -def fl_set_counter_bounds(pObject, minbound, maxbound): 
10872      """ fl_set_counter_bounds(pObject, minbound, maxbound) 
10873      """ 
10874   
10875      _fl_set_counter_bounds = cfuncproto( 
10876              load_so_libforms(), "fl_set_counter_bounds", 
10877              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10878              """void fl_set_counter_bounds(FL_OBJECT * ob, double min, 
10879                 double max) 
10880              """) 
10881      fminbound = convert_to_double(minbound) 
10882      fmaxbound = convert_to_double(maxbound) 
10883      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
10884      _fl_set_counter_bounds(pObject, fminbound, fmaxbound) 
10885   
10886   
10887 -def fl_set_counter_step(pObject, s, l): 
10888      """ fl_set_counter_step(pObject, s, l) 
10889      """ 
10890   
10891      _fl_set_counter_step = cfuncproto( 
10892              load_so_libforms(), "fl_set_counter_step", 
10893              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
10894              """void fl_set_counter_step(FL_OBJECT * ob, double s, double l) 
10895              """) 
10896      fs = convert_to_double(s) 
10897      fl = convert_to_double(l) 
10898      keep_elem_refs(pObject, s, l, fs, fl) 
10899      _fl_set_counter_step(pObject, fs, fl) 
10900   
10901   
10902 -def fl_set_counter_precision(pObject, prec): 
10903      """ fl_set_counter_precision(pObject, prec) 
10904      """ 
10905   
10906      _fl_set_counter_precision = cfuncproto( 
10907              load_so_libforms(), "fl_set_counter_precision", 
10908              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10909              """void fl_set_counter_precision(FL_OBJECT * ob, int prec) 
10910              """) 
10911      iprec = convert_to_int(prec) 
10912      keep_elem_refs(pObject, prec, iprec) 
10913      _fl_set_counter_precision(pObject, iprec) 
10914   
10915   
10916 -def fl_get_counter_precision(pObject): 
10917      """ fl_get_counter_precision(pObject) -> num. 
10918      """ 
10919   
10920      _fl_get_counter_precision = cfuncproto( 
10921              load_so_libforms(), "fl_get_counter_precision", 
10922              cty.c_int, [cty.POINTER(FL_OBJECT)], 
10923              """int fl_get_counter_precision(FL_OBJECT * ob) 
10924              """) 
10925      keep_elem_refs(pObject) 
10926      retval = _fl_get_counter_precision(pObject) 
10927      return retval 
10928   
10929   
10930 -def fl_set_counter_return(pObject, how): 
10931      """ fl_set_counter_return(pObject, how) 
10932      """ 
10933   
10934      _fl_set_counter_return = cfuncproto( 
10935              load_so_libforms(), "fl_set_counter_return", 
10936              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
10937              """void fl_set_counter_return(FL_OBJECT * ob, int how) 
10938              """) 
10939      ihow = convert_to_int(how) 
10940      keep_elem_refs(pObject, how, ihow) 
10941      _fl_set_counter_return(pObject, ihow) 
10942   
10943   
10944 -def fl_get_counter_value(pObject): 
10945      """ fl_get_counter_value(pObject) -> num. 
10946      """ 
10947   
10948      _fl_get_counter_value = cfuncproto( 
10949              load_so_libforms(), "fl_get_counter_value", 
10950              cty.c_double, [cty.POINTER(FL_OBJECT)], 
10951              """double fl_get_counter_value(FL_OBJECT * ob) 
10952              """) 
10953      keep_elem_refs(pObject) 
10954      retval = _fl_get_counter_value(pObject) 
10955      return retval 
10956   
10957   
10958  #def fl_get_counter_bounds(pObject, minbound, maxbound)       *API change* 
10959 -def fl_get_counter_bounds(pObject): 
10960      """ fl_get_counter_bounds(pObject) -> minbound, maxbound 
10961      """ 
10962   
10963      _fl_get_counter_bounds = cfuncproto( 
10964              load_so_libforms(), "fl_get_counter_bounds", 
10965              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10966              cty.POINTER(cty.c_double)], 
10967              """void fl_get_counter_bounds(FL_OBJECT * ob, double * min, 
10968                 double * max) 
10969              """) 
10970      minbound, pminbound = make_double_and_pointer() 
10971      maxbound, pmaxbound = make_double_and_pointer() 
10972      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
10973      _fl_get_counter_bounds(pObject, pminbound, pmaxbound) 
10974      return minbound, maxbound 
10975   
10976   
10977  #def fl_get_counter_step(pObject, s, l)       *API change* 
10978 -def fl_get_counter_step(pObject): 
10979      """ fl_get_counter_step(pObject) -> s, l 
10980      """ 
10981   
10982      _fl_get_counter_step = cfuncproto( 
10983              load_so_libforms(), "fl_get_counter_step", 
10984              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
10985              cty.POINTER(cty.c_double)], 
10986              """void fl_get_counter_step(FL_OBJECT * ob, double * s, 
10987                 double * l) 
10988              """) 
10989      s, ps = make_double_and_pointer() 
10990      l, pl = make_double_and_pointer() 
10991      keep_elem_refs(pObject, s, l, ps, pl) 
10992      _fl_get_counter_step(pObject, ps, pl) 
10993      return s, l 
10994   
10995   
10996  FL_VAL_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double, \ 
10997                                cty.c_int) 
10998   
10999 -def fl_set_counter_filter(pObject, py_ValFilter): 
11000      """ fl_set_counter_filter(pObject, ValFilter) 
11001      """ 
11002   
11003      _fl_set_counter_filter = cfuncproto( 
11004              load_so_libforms(), "fl_set_counter_filter", 
11005              None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 
11006              """void fl_set_counter_filter(FL_OBJECT * ob, 
11007                 FL_VAL_FILTER filter) 
11008              """) 
11009      c_ValFilter = FL_VAL_FILTER(py_ValFilter) 
11010      keep_cfunc_refs(c_ValFilter, py_ValFilter) 
11011      keep_elem_refs(pObject) 
11012      _fl_set_counter_filter(pObject, c_ValFilter) 
11013   
11014   
11015  # Functions to set and get the timeout value used by the 
11016  # counter code to control modification of the counter value. 
11017   
11018 -def fl_get_counter_repeat(pObject): 
11019      """ fl_get_counter_repeat(pObject) -> num. 
11020      """ 
11021   
11022      _fl_get_counter_repeat = cfuncproto( 
11023              load_so_libforms(), "fl_get_counter_repeat", 
11024              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11025              """int fl_get_counter_repeat(FL_OBJECT * ob) 
11026              """) 
11027      keep_elem_refs(pObject) 
11028      retval = _fl_get_counter_repeat(pObject) 
11029      return retval 
11030   
11031   
11032 -def fl_set_counter_repeat(pObject, msec): 
11033      """ fl_set_counter_repeat(pObject, msec) 
11034      """ 
11035   
11036      _fl_set_counter_repeat = cfuncproto( 
11037              load_so_libforms(), "fl_set_counter_repeat", 
11038              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11039              """void fl_set_counter_repeat(FL_OBJECT * ob, int millisec) 
11040              """) 
11041      imsec = convert_to_int(msec) 
11042      keep_elem_refs(pObject, msec, imsec) 
11043      _fl_set_counter_repeat(pObject, imsec) 
11044   
11045   
11046 -def fl_get_counter_min_repeat(pObject): 
11047      """ fl_get_counter_min_repeat(pObject) -> num. 
11048      """ 
11049   
11050      _fl_get_counter_min_repeat = cfuncproto( 
11051              load_so_libforms(), "fl_get_counter_min_repeat", 
11052              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11053              """int fl_get_counter_min_repeat(FL_OBJECT * ob) 
11054              """) 
11055      keep_elem_refs(pObject) 
11056      retval = _fl_get_counter_min_repeat(pObject) 
11057      return retval 
11058   
11059   
11060 -def fl_set_counter_min_repeat(pObject, msec): 
11061      """ fl_set_counter_min_repeat(pObject, msec) 
11062      """ 
11063   
11064      _fl_set_counter_min_repeat = cfuncproto( 
11065              load_so_libforms(), "fl_set_counter_min_repeat", 
11066              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11067              """void fl_set_counter_min_repeat(FL_OBJECT * ob, int millisec) 
11068              """) 
11069      imsec = convert_to_int(msec) 
11070      keep_elem_refs(pObject, msec, imsec) 
11071      _fl_set_counter_min_repeat(pObject, imsec) 
11072   
11073   
11074 -def fl_get_counter_speedjump(pObject): 
11075      """ fl_get_counter_speedjump(pObject) -> num. 
11076      """ 
11077   
11078      _fl_get_counter_speedjump = cfuncproto( 
11079              load_so_libforms(), "fl_get_counter_speedjump", 
11080              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11081              """int fl_get_counter_speedjump(FL_OBJECT * ob) 
11082              """) 
11083      keep_elem_refs(pObject) 
11084      retval = _fl_get_counter_speedjump(pObject) 
11085      return retval 
11086   
11087   
11088 -def fl_set_counter_speedjump(pObject, yesno): 
11089      """ fl_set_counter_speedjump(pObject, yesno) 
11090      """ 
11091   
11092      _fl_set_counter_speedjump = cfuncproto( 
11093              load_so_libforms(), "fl_set_counter_speedjump", 
11094              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11095              """void fl_set_counter_speedjump(FL_OBJECT * ob, int yes_no) 
11096              """) 
11097      iyesno = convert_to_int(yesno) 
11098      keep_elem_refs(pObject, yesno, iyesno) 
11099      _fl_set_counter_speedjump(pObject, iyesno) 
11100   
11101   
11102   
11103  ############################# 
11104  # forms.h (cursor.h) 
11105  # Cursor defs and prototypes 
11106  ############################# 
11107   
11108 -def fl_set_cursor(win, cursnum): 
11109      """ 
11110          fl_set_cursor(win, cursnum) 
11111   
11112          Set cursor for window to provided cursor number name. Name 
11113          is either the standard XC_ or Form defined 
11114   
11115          @param win : window 
11116          @param cursnum : cursor number 
11117      """ 
11118   
11119      _fl_set_cursor = cfuncproto( 
11120              load_so_libforms(), "fl_set_cursor", 
11121              None, [Window, cty.c_int], 
11122              """void fl_set_cursor(Window win, int name) 
11123              """) 
11124      ulwin = convert_to_Window(win) 
11125      icursnum = convert_to_int(cursnum) 
11126      keep_elem_refs(win, cursnum, ulwin, icursnum) 
11127      _fl_set_cursor(ulwin, icursnum) 
11128   
11129   
11130 -def fl_set_cursor_color(cursnum, fgcolr, bgcolr): 
11131      """ 
11132          fl_set_cursor_color(cursnum, fgcolr, bgcolr) 
11133   
11134          Sets foreground and background colors for cursor. 
11135   
11136          @param cursnum : cursor number 
11137          @param fgcolr : foreground color to be set 
11138          @param bgcolr : background color to be set 
11139      """ 
11140   
11141      _fl_set_cursor_color = cfuncproto( 
11142              load_so_libforms(), "fl_set_cursor_color", 
11143              None, [cty.c_int, FL_COLOR, FL_COLOR], 
11144              """void fl_set_cursor_color(int name, FL_COLOR fg, FL_COLOR bg) 
11145              """) 
11146      icursnum = convert_to_int(cursnum) 
11147      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
11148      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
11149      keep_elem_refs(cursnum, fgcolr, bgcolr, icursnum, ulfgcolr, ulbgcolr) 
11150      _fl_set_cursor_color(icursnum, ulfgcolr, ulbgcolr) 
11151   
11152   
11153 -def fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty): 
11154      """ fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty) -> num. 
11155      """ 
11156   
11157      _fl_create_bitmap_cursor = cfuncproto( 
11158              load_so_libforms(), "fl_create_bitmap_cursor", 
11159              cty.c_int, [STRING, STRING, cty.c_int, cty.c_int, cty.c_int, 
11160              cty.c_int], 
11161              """int fl_create_bitmap_cursor(const char * source, 
11162                 const char * mask, int w, int h, int hotx, int hoty) 
11163              """) 
11164      ssource = convert_to_string(source) 
11165      smaskstr = convert_to_string(maskstr) 
11166      iw = convert_to_int(w) 
11167      ih = convert_to_FL_Coord(h) 
11168      ihotx = convert_to_int(hotx) 
11169      ihoty = convert_to_int(hoty) 
11170      keep_elem_refs(source, maskstr, w, h, hotx, hoty, ssource, smaskstr, 
11171                     iw, ih, ihotx, ihoty) 
11172      retval = _fl_create_bitmap_cursor(ssource, smaskstr, iw, ih, ihotx, ihoty) 
11173      return retval 
11174   
11175   
11176 -def fl_create_animated_cursor(curnums, timeout): 
11177      """ fl_create_animated_cursor(curnums, timeout) -> num. 
11178      """ 
11179   
11180      _fl_create_animated_cursor = cfuncproto( 
11181              load_so_libforms(), "fl_create_animated_cursor", 
11182              cty.c_int, [cty.POINTER(cty.c_int), cty.c_int], 
11183              """int fl_create_animated_cursor(int * cur_names, int timeout) 
11184              """) 
11185      pcurnums = cty.cast(curnums, cty.POINTER(cty.c_int)) 
11186      #print "pcurnums", pcurnums 
11187      itimeout = convert_to_int(timeout) 
11188      keep_elem_refs(curnums, timeout, pcurnums, itimeout) 
11189      retval = _fl_create_animated_cursor(pcurnums, itimeout) 
11190      return retval 
11191   
11192   
11193 -def fl_get_cursor_byname(cursnum): 
11194      """ 
11195          fl_get_cursor_byname(cursnum) -> cursor 
11196   
11197          Return cursor corresponding to number. 
11198           
11199          @param cursnum : cursor number 
11200      """ 
11201   
11202      _fl_get_cursor_byname = cfuncproto( 
11203              load_so_libforms(), "fl_get_cursor_byname", 
11204              Cursor, [cty.c_int], 
11205              """Cursor fl_get_cursor_byname(int name) 
11206              """) 
11207      icursnum = convert_to_int(cursnum) 
11208      keep_elem_refs(cursnum, icursnum) 
11209      retval = _fl_get_cursor_byname(icursnum) 
11210      return retval 
11211   
11212   
11213 -def fl_reset_cursor(win): 
11214      """ 
11215          Reset used cursor, reverting to default one. 
11216      """ 
11217   
11218      fl_set_cursor(win, FL_DEFAULT_CURSOR) 
11219   
11220   
11221   
11222  ################### 
11223  # forms.h (dial.h) 
11224  ################### 
11225   
11226  # Routines 
11227   
11228 -def fl_create_dial(dialtype, x, y, w, h, label): 
11229      """ fl_create_dial(dialtype, x, y, w, h, label) -> pObject 
11230      """ 
11231   
11232      _fl_create_dial = cfuncproto( 
11233              load_so_libforms(), "fl_create_dial", 
11234              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11235              FL_Coord, STRING], 
11236              """FL_OBJECT * fl_create_dial(int type, FL_Coord x, FL_Coord y, 
11237                 FL_Coord w, FL_Coord h, const char * label) 
11238              """) 
11239      check_admitted_listvalues(dialtype, DIALTYPE_list) 
11240      idialtype = convert_to_int(dialtype) 
11241      ix = convert_to_FL_Coord(x) 
11242      iy = convert_to_FL_Coord(y) 
11243      iw = convert_to_FL_Coord(w) 
11244      ih = convert_to_FL_Coord(h) 
11245      slabel = convert_to_string(label) 
11246      keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 
11247                     iw, ih, slabel) 
11248      retval = _fl_create_dial(idialtype, ix, iy, iw, ih, slabel) 
11249      return retval 
11250   
11251   
11252 -def fl_add_dial(dialtype, x, y, w, h, label): 
11253      """ fl_add_dial(dialtype, x, y, w, h, label) -> pObject 
11254      """ 
11255   
11256      _fl_add_dial = cfuncproto( 
11257              load_so_libforms(), "fl_add_dial", 
11258              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11259              FL_Coord, STRING], 
11260              """FL_OBJECT * fl_add_dial(int type, FL_Coord x, FL_Coord y, 
11261                 FL_Coord w, FL_Coord h, const char * label) 
11262              """) 
11263      check_admitted_listvalues(dialtype, DIALTYPE_list) 
11264      idialtype = convert_to_int(dialtype) 
11265      ix = convert_to_FL_Coord(x) 
11266      iy = convert_to_FL_Coord(y) 
11267      iw = convert_to_FL_Coord(w) 
11268      ih = convert_to_FL_Coord(h) 
11269      slabel = convert_to_string(label) 
11270      keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 
11271                     iw, ih, slabel) 
11272      retval = _fl_add_dial(idialtype, ix, iy, iw, ih, slabel) 
11273      return retval 
11274   
11275   
11276 -def fl_set_dial_value(pObject, val): 
11277      """ fl_set_dial_value(pObject, val) 
11278      """ 
11279   
11280      _fl_set_dial_value = cfuncproto( 
11281              load_so_libforms(), "fl_set_dial_value", 
11282              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
11283              """void fl_set_dial_value(FL_OBJECT * ob, double val) 
11284              """) 
11285      fval = convert_to_double(val) 
11286      keep_elem_refs(pObject, val, fval) 
11287      _fl_set_dial_value(pObject, fval) 
11288   
11289   
11290 -def fl_get_dial_value(pObject): 
11291      """ fl_get_dial_value(pObject) -> num. 
11292      """ 
11293   
11294      _fl_get_dial_value = cfuncproto( 
11295              load_so_libforms(), "fl_get_dial_value", 
11296              cty.c_double, [cty.POINTER(FL_OBJECT)], 
11297              """double fl_get_dial_value(FL_OBJECT * ob) 
11298              """) 
11299      keep_elem_refs(pObject) 
11300      retval = _fl_get_dial_value(pObject) 
11301      return retval 
11302   
11303   
11304 -def fl_set_dial_bounds(pObject, minbound, maxbound): 
11305      """ fl_set_dial_bounds(pObject, minbound, maxbound) 
11306      """ 
11307   
11308      _fl_set_dial_bounds = cfuncproto( 
11309              load_so_libforms(), "fl_set_dial_bounds", 
11310              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
11311              """void fl_set_dial_bounds(FL_OBJECT * ob, double min, 
11312                 double max) 
11313              """) 
11314      fminbound = convert_to_double(minbound) 
11315      fmaxbound = convert_to_double(maxbound) 
11316      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
11317      _fl_set_dial_bounds(pObject, fminbound, fmaxbound) 
11318   
11319   
11320  #def fl_get_dial_bounds(pObject, minbound, maxbound)       *API change* 
11321 -def fl_get_dial_bounds(pObject): 
11322      """ fl_get_dial_bounds(pObject) -> minbound, maxbound 
11323      """ 
11324   
11325      _fl_get_dial_bounds = cfuncproto( 
11326              load_so_libforms(), "fl_get_dial_bounds", 
11327              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
11328              cty.POINTER(cty.c_double)], 
11329              """void fl_get_dial_bounds(FL_OBJECT * ob, double * min, 
11330                 double * max) 
11331              """) 
11332      minbound, pminbound = make_double_and_pointer() 
11333      maxbound, pmaxbound = make_double_and_pointer() 
11334      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
11335      _fl_get_dial_bounds(pObject, pminbound, pmaxbound) 
11336      return minbound, maxbound 
11337   
11338   
11339 -def fl_set_dial_step(pObject, value): 
11340      """ fl_set_dial_step(pObject, value) 
11341      """ 
11342   
11343      _fl_set_dial_step = cfuncproto( 
11344              load_so_libforms(), "fl_set_dial_step", 
11345              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
11346              """void fl_set_dial_step(FL_OBJECT * ob, double value) 
11347              """) 
11348      fvalue = convert_to_double(value) 
11349      keep_elem_refs(pObject, value, fvalue) 
11350      _fl_set_dial_step(pObject, fvalue) 
11351   
11352   
11353 -def fl_set_dial_return(pObject, value): 
11354      """ fl_set_dial_return(pObject, value) 
11355      """ 
11356   
11357      _fl_set_dial_return = cfuncproto( 
11358              load_so_libforms(), "fl_set_dial_return", 
11359              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11360              """void fl_set_dial_return(FL_OBJECT * ob, int value) 
11361              """) 
11362      ivalue = convert_to_int(value) 
11363      keep_elem_refs(pObject, value, ivalue) 
11364      _fl_set_dial_return(pObject, ivalue) 
11365   
11366   
11367 -def fl_set_dial_angles(pObject, angmin, angmax): 
11368      """ fl_set_dial_angles(pObject, angmin, angmax) 
11369      """ 
11370   
11371      _fl_set_dial_angles = cfuncproto( 
11372              load_so_libforms(), "fl_set_dial_angles", 
11373              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
11374              """void fl_set_dial_angles(FL_OBJECT * ob, double amin, 
11375                 double amax) 
11376              """) 
11377      fangmin = convert_to_double(angmin) 
11378      fangmax = convert_to_double(angmax) 
11379      keep_elem_refs(pObject, angmin, angmax, fangmin, fangmax) 
11380      _fl_set_dial_angles(pObject, fangmin, fangmax) 
11381   
11382   
11383 -def fl_set_dial_cross(pObject, flag): 
11384      """ fl_set_dial_cross(pObject, flag) 
11385      """ 
11386   
11387      _fl_set_dial_cross = cfuncproto( 
11388              load_so_libforms(), "fl_set_dial_cross", 
11389              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11390              """void fl_set_dial_cross(FL_OBJECT * ob, int flag) 
11391              """) 
11392      iflag = convert_to_int(flag) 
11393      keep_elem_refs(pObject, flag, iflag) 
11394      _fl_set_dial_cross(pObject, iflag) 
11395   
11396   
11397  fl_set_dial_crossover = fl_set_dial_cross 
11398   
11399   
11400 -def fl_set_dial_direction(pObject, directn): 
11401      """ fl_set_dial_direction(pObject, directn) 
11402      """ 
11403   
11404      _fl_set_dial_direction = cfuncproto( 
11405              load_so_libforms(), "fl_set_dial_direction", 
11406              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11407              """void fl_set_dial_direction(FL_OBJECT * ob, int dir) 
11408              """) 
11409      idirectn = convert_to_int(directn) 
11410      keep_elem_refs(pObject, directn, idirectn) 
11411      _fl_set_dial_direction(pObject, idirectn) 
11412   
11413   
11414   
11415  ############################################ 
11416  # forms.h (filesys.h) 
11417  # Convenience functions to read a directory 
11418  ############################################ 
11419   
11420  # read dir with pattern filtering. All dirs read might be cached. 
11421  # must not change dirlist in anyway. 
11422   
11423  #def fl_get_dirlist(directory, pattern, n, rescan)       *API change* 
11424 -def fl_get_dirlist(directory, pattern, rescan): 
11425      """ fl_get_dirlist(directory, pattern, rescan) -> pDirList, n 
11426      """ 
11427   
11428      _fl_get_dirlist = cfuncproto( 
11429              load_so_libforms(), "fl_get_dirlist", 
11430              cty.POINTER(FL_Dirlist), [STRING, STRING, cty.POINTER(cty.c_int), 
11431              cty.c_int], 
11432              """const char * fl_get_dirlist(const char * dir, 
11433                 const char * pattern, int * n, int rescan) 
11434              """) 
11435      sdirectory = convert_to_string(directory) 
11436      spattern = convert_to_string(pattern) 
11437      n, pn = make_int_and_pointer() 
11438      irescan = convert_to_int(rescan) 
11439      keep_elem_refs(directory, pattern, n, rescan, sdirectory, spattern, 
11440                     pn, irescan) 
11441      retval = _fl_get_dirlist(sdirectory, spattern, pn, irescan) 
11442      return retval, n 
11443   
11444   
11445  FL_DIRLIST_FILTER = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_int) 
11446   
11447 -def fl_set_dirlist_filter(py_DirFilter): 
11448      """ fl_set_dirlist_filter(py_DirFilter) -> dirlist_filter func. 
11449      """ 
11450   
11451      _fl_set_dirlist_filter = cfuncproto( 
11452              load_so_libforms(), "fl_set_dirlist_filter", 
11453              FL_DIRLIST_FILTER, [FL_DIRLIST_FILTER], 
11454              """FL_DIRLIST_FILTER fl_set_dirlist_filter( \ 
11455                 FL_DIRLIST_FILTER filter) 
11456              """) 
11457      c_DirFilter = FL_DIRLIST_FILTER(py_DirFilter) 
11458      keep_cfunc_refs(c_DirFilter, py_DirFilter) 
11459      retval = _fl_set_dirlist_filter(c_DirFilter) 
11460      return retval 
11461   
11462   
11463 -def fl_set_dirlist_sort(method): 
11464      """ fl_set_dirlist_sort(method) -> num. 
11465      """ 
11466   
11467      _fl_set_dirlist_sort = cfuncproto( 
11468              load_so_libforms(), "fl_set_dirlist_sort", 
11469              cty.c_int, [cty.c_int], 
11470              """int fl_set_dirlist_sort(int method) 
11471              """) 
11472      imethod = convert_to_int(method) 
11473      keep_elem_refs(method, imethod) 
11474      retval = _fl_set_dirlist_sort(imethod) 
11475      return retval 
11476   
11477   
11478 -def fl_set_dirlist_filterdir(yes): 
11479      """ fl_set_dirlist_filterdir(yes) -> num. 
11480      """ 
11481   
11482      _fl_set_dirlist_filterdir = cfuncproto( 
11483              load_so_libforms(), "fl_set_dirlist_filterdir", 
11484              cty.c_int, [cty.c_int], 
11485              """int fl_set_dirlist_filterdir(int yes) 
11486              """) 
11487      iyes = convert_to_int(yes) 
11488      keep_elem_refs(yes, iyes) 
11489      retval = _fl_set_dirlist_filterdir(iyes) 
11490      return retval 
11491   
11492   
11493 -def fl_free_dirlist(pDirList): 
11494      """ fl_free_dirlist(pDirList) 
11495      """ 
11496   
11497      _fl_free_dirlist = cfuncproto( 
11498              load_so_libforms(), "fl_free_dirlist", 
11499              None, [cty.POINTER(FL_Dirlist)], 
11500              """void fl_free_dirlist(FL_Dirlist * dl) 
11501              """) 
11502      keep_elem_refs(pDirList) 
11503      _fl_free_dirlist(pDirList) 
11504   
11505   
11506  # Free all directory caches 
11507   
11508 -def fl_free_all_dirlist(): 
11509      """ fl_free_all_dirlist() 
11510      """ 
11511   
11512      _fl_free_all_dirlist = cfuncproto( 
11513              load_so_libforms(), "fl_free_all_dirlist", 
11514              None, [], 
11515              """void fl_free_all_dirlist() 
11516              """) 
11517      _fl_free_all_dirlist() 
11518   
11519   
11520 -def fl_is_valid_dir(name): 
11521      """ fl_is_valid_dir(name) -> num. 
11522      """ 
11523   
11524      _fl_is_valid_dir = cfuncproto( 
11525              load_so_libforms(), "fl_is_valid_dir", 
11526              cty.c_int, [STRING], 
11527              """int fl_is_valid_dir(const char * name) 
11528              """) 
11529      sname = convert_to_string(name) 
11530      keep_elem_refs(name, sname) 
11531      retval = _fl_is_valid_dir(sname) 
11532      return retval 
11533   
11534   
11535 -def fl_fmtime(timestr): 
11536      """ fl_fmtime(timestr) -> num. 
11537      """ 
11538   
11539      _fl_fmtime = cfuncproto( 
11540              load_so_libforms(), "fl_fmtime", 
11541              cty.c_ulong, [STRING], 
11542              """long unsigned int fl_fmtime(const char * s) 
11543              """) 
11544      stimestr = convert_to_string(timestr) 
11545      keep_elem_refs(timestr, stimestr) 
11546      retval = _fl_fmtime(stimestr) 
11547      return retval 
11548   
11549   
11550 -def fl_fix_dirname(directory): 
11551      """ fl_fix_dirname(directory) -> dirname string 
11552      """ 
11553   
11554      _fl_fix_dirname = cfuncproto( 
11555              load_so_libforms(), "fl_fix_dirname", 
11556              STRING, [STRING], 
11557              """char * fl_fix_dirname(char * dir) 
11558              """) 
11559      sdirectory = convert_to_string(directory) 
11560      keep_elem_refs(directory, sdirectory) 
11561      retval = _fl_fix_dirname(sdirectory) 
11562      return retval 
11563   
11564   
11565   
11566  ################### 
11567  # forms.h (flps.h) 
11568  ################### 
11569   
11570  # postscript stuff 
11571   
11572 -def flps_init(): 
11573      """ flps_init() -> flps_control class 
11574      """ 
11575   
11576      _flps_init = cfuncproto( 
11577              load_so_libflimage(), "flps_init", 
11578              cty.POINTER(FLPS_CONTROL), [], 
11579              """)FLPS_CONTROL * flps_init() 
11580              """) 
11581      retval = _flps_init() 
11582      return retval 
11583   
11584   
11585 -def fl_object_ps_dump(pObject, fname): 
11586      """ fl_object_ps_dump(pObject, fname) -> num. 
11587      """ 
11588   
11589      _fl_object_ps_dump = cfuncproto( 
11590              load_so_libflimage(), "fl_object_ps_dump", 
11591              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
11592              """int fl_object_ps_dump(FL_OBJECT * ob, const char * fname) 
11593              """) 
11594      sfname = convert_to_string(fname) 
11595      keep_elem_refs(pObject, fname, sfname) 
11596      retval = _fl_object_ps_dump(pObject, sfname) 
11597      return retval 
11598   
11599   
11600   
11601  ########################## 
11602  # forms.h (formbrowser.h) 
11603  ########################## 
11604   
11605 -def fl_addto_formbrowser(pObject, pForm): 
11606      """ fl_addto_formbrowser(pObject, pForm) -> num. 
11607      """ 
11608   
11609      _fl_addto_formbrowser = cfuncproto( 
11610              load_so_libforms(), "fl_addto_formbrowser", 
11611              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11612              """int fl_addto_formbrowser(FL_OBJECT * ob, FL_FORM * form) 
11613              """) 
11614      keep_elem_refs(pObject, pForm) 
11615      retval = _fl_addto_formbrowser(pObject, pForm) 
11616      return retval 
11617   
11618   
11619 -def fl_delete_formbrowser_bynumber(pObject, num): 
11620      """ fl_delete_formbrowser_bynumber(pObject, num) -> pForm 
11621      """ 
11622   
11623      _fl_delete_formbrowser_bynumber = cfuncproto( 
11624              load_so_libforms(), "fl_delete_formbrowser_bynumber", 
11625              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11626              """FL_FORM * fl_delete_formbrowser_bynumber(FL_OBJECT * ob, 
11627                 int num) 
11628              """) 
11629      inum = convert_to_int(num) 
11630      keep_elem_refs(pObject, num, inum) 
11631      retval = _fl_delete_formbrowser_bynumber(pObject, inum) 
11632      return retval 
11633   
11634   
11635 -def fl_delete_formbrowser(pObject, pFormCandidate): 
11636      """ fl_delete_formbrowser(pObject, pFormCandidate) -> num. 
11637      """ 
11638   
11639      _fl_delete_formbrowser = cfuncproto( 
11640              load_so_libforms(), "fl_delete_formbrowser", 
11641              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11642              """int fl_delete_formbrowser(FL_OBJECT * ob, 
11643                 FL_FORM * candidate_form) 
11644              """) 
11645      keep_elem_refs(pObject, pFormCandidate) 
11646      retval = _fl_delete_formbrowser(pObject, pFormCandidate) 
11647      return retval 
11648   
11649   
11650 -def fl_replace_formbrowser(pObject, num, pForm): 
11651      """ fl_replace_formbrowser(pObject, num, pForm) 
11652      """ 
11653   
11654      _fl_replace_formbrowser = cfuncproto( 
11655              load_so_libforms(), "fl_replace_formbrowser", 
11656              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int, 
11657              cty.POINTER(FL_FORM)], 
11658              """FL_FORM * fl_replace_formbrowser(FL_OBJECT * ob, int num, 
11659                 FL_FORM * form) 
11660              """) 
11661      inum = convert_to_int(num) 
11662      keep_elem_refs(pObject, num, pForm, inum) 
11663      retval = _fl_replace_formbrowser(pObject, inum, pForm) 
11664      return retval 
11665   
11666   
11667 -def fl_insert_formbrowser(pObject, line, pFormNew): 
11668      """ fl_insert_formbrowser(pObject, line, pFormNew) -> num. 
11669      """ 
11670   
11671      _fl_insert_formbrowser = cfuncproto( 
11672              load_so_libforms(), "fl_insert_formbrowser", 
11673              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, \ 
11674              cty.POINTER(FL_FORM)], 
11675              """int fl_insert_formbrowser(FL_OBJECT * ob, int line, 
11676                 FL_FORM * new_form) 
11677              """) 
11678      iline = convert_to_int(line) 
11679      keep_elem_refs(pObject, line, iline, pFormNew) 
11680      retval = _fl_insert_formbrowser(pObject, iline, pFormNew) 
11681      return retval 
11682   
11683   
11684  #def fl_get_formbrowser_area(pObject, x, y, w, h)       *API change* 
11685 -def fl_get_formbrowser_area(pObject): 
11686      """ fl_get_formbrowser_area(pObject) -> num., x, y, w, h 
11687      """ 
11688   
11689      _fl_get_formbrowser_area = cfuncproto( 
11690              load_so_libforms(), "fl_get_formbrowser_area", 
11691              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
11692              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), \ 
11693              cty.POINTER(cty.c_int)], 
11694              """int fl_get_formbrowser_area(FL_OBJECT * ob, int * x, int * y, 
11695                 int * w, int * h) 
11696              """) 
11697      x, px = make_int_and_pointer() 
11698      y, py = make_int_and_pointer() 
11699      w, pw = make_int_and_pointer() 
11700      h, ph = make_int_and_pointer() 
11701      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
11702      retval = _fl_get_formbrowser_area(pObject, px, py, pw, ph) 
11703      return retval, x, y, w, h 
11704   
11705   
11706 -def fl_set_formbrowser_scroll(pObject, how): 
11707      """ fl_set_formbrowser_scroll(pObject, how) 
11708      """ 
11709   
11710      _fl_set_formbrowser_scroll = cfuncproto( 
11711              load_so_libforms(), "fl_set_formbrowser_scroll", 
11712              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11713              """void fl_set_formbrowser_scroll(FL_OBJECT * ob, int how) 
11714              """) 
11715      ihow = convert_to_int(how) 
11716      keep_elem_refs(pObject, how, ihow) 
11717      _fl_set_formbrowser_scroll(pObject, ihow) 
11718   
11719   
11720 -def fl_set_formbrowser_hscrollbar(pObject, how): 
11721      """ fl_set_formbrowser_hscrollbar(pObject, how) 
11722      """ 
11723   
11724      _fl_set_formbrowser_hscrollbar = cfuncproto( 
11725              load_so_libforms(), "fl_set_formbrowser_hscrollbar", 
11726              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11727              """void fl_set_formbrowser_hscrollbar(FL_OBJECT * ob, int how) 
11728              """) 
11729      ihow = convert_to_int(how) 
11730      keep_elem_refs(pObject, how, ihow) 
11731      _fl_set_formbrowser_hscrollbar(pObject, ihow) 
11732   
11733   
11734 -def fl_set_formbrowser_vscrollbar(pObject, how): 
11735      """ fl_set_formbrowser_vscrollbar(pObject, how) 
11736      """ 
11737   
11738      _fl_set_formbrowser_vscrollbar = cfuncproto( 
11739              load_so_libforms(), "fl_set_formbrowser_vscrollbar", 
11740              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
11741              """void fl_set_formbrowser_vscrollbar(FL_OBJECT * ob, int how) 
11742              """) 
11743      ihow = convert_to_int(how) 
11744      keep_elem_refs(pObject, how, ihow) 
11745      _fl_set_formbrowser_vscrollbar(pObject, ihow) 
11746   
11747   
11748 -def fl_get_formbrowser_topform(pObject): 
11749      """ fl_get_formbrowser_topform(pObject) -> pForm 
11750      """ 
11751   
11752      _fl_get_formbrowser_topform = cfuncproto( 
11753              load_so_libforms(), "fl_get_formbrowser_topform", 
11754              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
11755              """FL_FORM * fl_get_formbrowser_topform(FL_OBJECT * ob) 
11756              """) 
11757      keep_elem_refs(pObject) 
11758      retval = _fl_get_formbrowser_topform(pObject) 
11759      return retval 
11760   
11761   
11762 -def fl_set_formbrowser_topform(pObject, pForm): 
11763      """ fl_set_formbrowser_topform(pObject, pForm) -> num. 
11764      """ 
11765   
11766      _fl_set_formbrowser_topform = cfuncproto( 
11767              load_so_libforms(), "fl_set_formbrowser_topform", 
11768              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11769              """int fl_set_formbrowser_topform(FL_OBJECT * ob, FL_FORM * form) 
11770              """) 
11771      keep_elem_refs(pObject, pForm) 
11772      retval = _fl_set_formbrowser_topform(pObject, pForm) 
11773      return retval 
11774   
11775   
11776 -def fl_set_formbrowser_topform_bynumber(pObject, n): 
11777      """ fl_set_formbrowser_topform_bynumber(pObject, n) -> pForm 
11778      """ 
11779   
11780      _fl_set_formbrowser_topform_bynumber = cfuncproto( 
11781              load_so_libforms(), "fl_set_formbrowser_topform_bynumber", 
11782              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11783              """FL_FORM * fl_set_formbrowser_topform_bynumber( \ 
11784                 FL_OBJECT * ob, int n) 
11785              """) 
11786      inum = convert_to_int(n) 
11787      keep_elem_refs(pObject, n, inum) 
11788      retval = _fl_set_formbrowser_topform_bynumber(pObject, inum) 
11789      return retval 
11790   
11791   
11792 -def fl_set_formbrowser_xoffset(pObject, offset): 
11793      """ 
11794          fl_set_formbrowser_xoffset(pObject, offset) -> num. 
11795   
11796          Scrolls within a formbrowser in horizontal direction. 
11797   
11798          @param pObject : pointer to formbrowser object 
11799          @param offset : positive number, measuring in pixels the offset 
11800             from the the natural position from the left 
11801      """ 
11802   
11803      _fl_set_formbrowser_xoffset = cfuncproto( 
11804              load_so_libforms(), "fl_set_formbrowser_xoffset", 
11805              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
11806              """int fl_set_formbrowser_xoffset(FL_OBJECT * ob, int offset) 
11807              """) 
11808      ioffset = convert_to_int(offset) 
11809      keep_elem_refs(pObject, offset, ioffset) 
11810      retval = _fl_set_formbrowser_xoffset(pObject, ioffset) 
11811      return retval 
11812   
11813   
11814 -def fl_set_formbrowser_yoffset(pObject, offset): 
11815      """ 
11816          fl_set_formbrowser_yoffset(pObject, offset) -> num. 
11817   
11818          Scrolls within a formbrowser in vertical direction. 
11819   
11820          @param pObject : pointer to formbrowser object 
11821          @param offset : positive number, measuring in pixels the offset 
11822             from the the natural position from the top 
11823      """ 
11824   
11825      _fl_set_formbrowser_yoffset = cfuncproto( 
11826              load_so_libforms(), "fl_set_formbrowser_yoffset", 
11827              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
11828              """int fl_set_formbrowser_yoffset(FL_OBJECT * ob, int offset) 
11829              """) 
11830      ioffset = convert_to_int(offset) 
11831      keep_elem_refs(pObject, offset, ioffset) 
11832      retval = _fl_set_formbrowser_yoffset(pObject, ioffset) 
11833      return retval 
11834   
11835   
11836 -def fl_get_formbrowser_xoffset(pObject): 
11837      """ 
11838          fl_get_formbrowser_xoffset(pObject) -> num. 
11839   
11840          Returns the current horizontal offset from left in pixel of a 
11841          formbrowser. 
11842   
11843          @param pObject : pointer to formbrowser object 
11844      """ 
11845   
11846      _fl_get_formbrowser_xoffset = cfuncproto( 
11847              load_so_libforms(), "fl_get_formbrowser_xoffset", 
11848              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11849              """int fl_get_formbrowser_xoffset(FL_OBJECT * ob) 
11850              """) 
11851      keep_elem_refs(pObject) 
11852      retval = _fl_get_formbrowser_xoffset(pObject) 
11853      return retval 
11854   
11855   
11856 -def fl_get_formbrowser_yoffset(pObject): 
11857      """ 
11858          fl_get_formbrowser_yoffset(pObject) -> num. 
11859   
11860          Returns the current vertical offset from top in pixel of a 
11861          formbrowser. 
11862   
11863          @param pObject : pointer to formbrowser object 
11864      """ 
11865   
11866      _fl_get_formbrowser_yoffset = cfuncproto( 
11867              load_so_libforms(), "fl_get_formbrowser_yoffset", 
11868              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11869              """int fl_get_formbrowser_yoffset(FL_OBJECT * ob) 
11870              """) 
11871      keep_elem_refs(pObject) 
11872      retval = _fl_get_formbrowser_yoffset(pObject) 
11873      return retval 
11874   
11875   
11876 -def fl_find_formbrowser_form_number(pObject, pFormCandidate): 
11877      """ fl_find_formbrowser_form_number(pObject, pFormCandidate) -> num. 
11878      """ 
11879   
11880      _fl_find_formbrowser_form_number = cfuncproto( 
11881              load_so_libforms(), "fl_find_formbrowser_form_number", 
11882              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
11883              """int fl_find_formbrowser_form_number(FL_OBJECT * ob, 
11884                 FL_FORM * candidate_form) 
11885              """) 
11886      keep_elem_refs(pObject, pFormCandidate) 
11887      retval = _fl_find_formbrowser_form_number(pObject, pFormCandidate) 
11888      return retval 
11889   
11890   
11891 -def fl_add_formbrowser(frmbrwstype, x, y, w, h, label): 
11892      """ fl_add_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 
11893      """ 
11894   
11895      _fl_add_formbrowser = cfuncproto( 
11896              load_so_libforms(), "fl_add_formbrowser", 
11897              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 
11898              FL_Coord, FL_Coord, STRING], 
11899              """FL_OBJECT * fl_add_formbrowser(int type, FL_Coord x, 
11900                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
11901              """) 
11902      check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 
11903      ifrmbrwstype = convert_to_int(frmbrwstype) 
11904      ix = convert_to_FL_Coord(x) 
11905      iy = convert_to_FL_Coord(y) 
11906      iw = convert_to_FL_Coord(w) 
11907      ih = convert_to_FL_Coord(h) 
11908      slabel = convert_to_string(label) 
11909      keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 
11910                     iw, ih, slabel) 
11911      retval = _fl_add_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 
11912      return retval 
11913   
11914   
11915 -def fl_create_formbrowser(frmbrwstype, x, y, w, h, label): 
11916      """ fl_create_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 
11917      """ 
11918   
11919      _fl_create_formbrowser = cfuncproto( 
11920              load_so_libforms(), "fl_create_formbrowser", 
11921              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 
11922              FL_Coord, FL_Coord, STRING], 
11923              """FL_OBJECT * fl_create_formbrowser(int type, FL_Coord x, 
11924                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
11925              """) 
11926      check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 
11927      ifrmbrwstype = convert_to_int(frmbrwstype) 
11928      ix = convert_to_FL_Coord(x) 
11929      iy = convert_to_FL_Coord(y) 
11930      iw = convert_to_FL_Coord(w) 
11931      ih = convert_to_FL_Coord(h) 
11932      slabel = convert_to_string(label) 
11933      keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 
11934                     iw, ih, slabel) 
11935      retval = _fl_create_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 
11936      return retval 
11937   
11938   
11939 -def fl_get_formbrowser_numforms(pObject): 
11940      """ fl_get_formbrowser_numforms(pObject) -> forms num. 
11941      """ 
11942   
11943      _fl_get_formbrowser_numforms = cfuncproto( 
11944              load_so_libforms(), "fl_get_formbrowser_numforms", 
11945              cty.c_int, [cty.POINTER(FL_OBJECT)], 
11946              """int fl_get_formbrowser_numforms(FL_OBJECT * ob) 
11947              """) 
11948      keep_elem_refs(pObject) 
11949      retval = _fl_get_formbrowser_numforms(pObject) 
11950      return retval 
11951   
11952   
11953 -def fl_get_formbrowser_form(pObject, n): 
11954      """ fl_get_formbrowser_form(pObject, n) -> pForm 
11955      """ 
11956   
11957      _fl_get_formbrowser_form = cfuncproto( 
11958              load_so_libforms(), "fl_get_formbrowser_form", 
11959              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
11960              """FL_FORM * fl_get_formbrowser_form(FL_OBJECT * ob, int n) 
11961              """) 
11962      inum = convert_to_int(n) 
11963      keep_elem_refs(pObject, n, inum) 
11964      retval = _fl_get_formbrowser_form(pObject, inum) 
11965      return retval 
11966   
11967   
11968   
11969  #################### 
11970  # forms.h (frame.h) 
11971  #################### 
11972   
11973 -def fl_create_frame(frametype, x, y, w, h, label): 
11974      """ fl_create_frame(frametype, x, y, w, h, label) -> pObject 
11975      """ 
11976   
11977      _fl_create_frame = cfuncproto( 
11978              load_so_libforms(), "fl_create_frame", 
11979              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
11980              FL_Coord, STRING], 
11981              """FL_OBJECT * fl_create_frame(int type, FL_Coord x, FL_Coord y, 
11982                 FL_Coord w, FL_Coord h, const char * label) 
11983              """) 
11984      check_admitted_listvalues(frametype, FRAMETYPE_list) 
11985      iframetype = convert_to_int(frametype) 
11986      ix = convert_to_FL_Coord(x) 
11987      iy = convert_to_FL_Coord(y) 
11988      iw = convert_to_FL_Coord(w) 
11989      ih = convert_to_FL_Coord(h) 
11990      slabel = convert_to_string(label) 
11991      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
11992                     iw, ih, slabel) 
11993      retval = _fl_create_frame(iframetype, ix, iy, iw, ih, slabel) 
11994      return retval 
11995   
11996   
11997 -def fl_add_frame(frametype, x, y, w, h, label): 
11998      """ fl_add_frame(frametype, x, y, w, h, label) -> pObject 
11999      """ 
12000   
12001      _fl_add_frame = cfuncproto( 
12002              load_so_libforms(), "fl_add_frame", 
12003              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12004              FL_Coord, STRING], 
12005              """FL_OBJECT * fl_add_frame(int type, FL_Coord x, FL_Coord y, 
12006                 FL_Coord w, FL_Coord h, const char * label) 
12007              """) 
12008      check_admitted_listvalues(frametype, FRAMETYPE_list) 
12009      iframetype = convert_to_int(frametype) 
12010      ix = convert_to_FL_Coord(x) 
12011      iy = convert_to_FL_Coord(y) 
12012      iw = convert_to_FL_Coord(w) 
12013      ih = convert_to_FL_Coord(h) 
12014      slabel = convert_to_string(label) 
12015      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
12016                     iw, ih, slabel) 
12017      retval = _fl_add_frame(iframetype, ix, iy, iw, ih, slabel) 
12018      return retval 
12019   
12020   
12021  # labeld frame 
12022   
12023 -def fl_create_labelframe(frametype, x, y, w, h, label): 
12024      """ fl_create_labelframe(frametype, x, y, w, h, label) -> pObject 
12025      """ 
12026   
12027      _fl_create_labelframe = cfuncproto( 
12028              load_so_libforms(), "fl_create_labelframe", 
12029              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12030              FL_Coord, STRING], 
12031              """FL_OBJECT * fl_create_labelframe(int type, FL_Coord x, 
12032                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
12033              """) 
12034      iframetype = convert_to_int(frametype) 
12035      ix = convert_to_FL_Coord(x) 
12036      iy = convert_to_FL_Coord(y) 
12037      iw = convert_to_FL_Coord(w) 
12038      ih = convert_to_FL_Coord(h) 
12039      slabel = convert_to_string(label) 
12040      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
12041                     iw, ih, slabel) 
12042      retval = _fl_create_labelframe(iframetype, ix, iy, iw, ih, slabel) 
12043      return retval 
12044   
12045   
12046 -def fl_add_labelframe(frametype, x, y, w, h, label): 
12047      """ fl_add_labelframe(frametype, x, y, w, h, label) -> pObject 
12048      """ 
12049   
12050      _fl_add_labelframe = cfuncproto( 
12051              load_so_libforms(), "fl_add_labelframe", 
12052              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12053              FL_Coord, STRING], 
12054              """FL_OBJECT * fl_add_labelframe(int type, FL_Coord x, FL_Coord y, 
12055                 FL_Coord w, FL_Coord h, const char * label) 
12056              """) 
12057      iframetype = convert_to_int(frametype) 
12058      ix = convert_to_FL_Coord(x) 
12059      iy = convert_to_FL_Coord(y) 
12060      iw = convert_to_FL_Coord(w) 
12061      ih = convert_to_FL_Coord(h) 
12062      slabel = convert_to_string(label) 
12063      keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 
12064                     iw, ih, slabel) 
12065      retval = _fl_add_labelframe(iframetype, ix, iy, iw, ih, slabel) 
12066      return retval 
12067   
12068   
12069   
12070  ##################### 
12071  # forms.h (free.h) 
12072  # Object Class: Free 
12073  ##################### 
12074   
12075 -def fl_create_free(freetype, x, y, w, h, label, py_HandlePtr): 
12076      """ fl_create_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 
12077      """ 
12078   
12079      _fl_create_free = cfuncproto( 
12080              load_so_libforms(), "fl_create_free", 
12081              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12082              FL_Coord, STRING, FL_HANDLEPTR], 
12083              """FL_OBJECT * fl_create_free(int type, FL_Coord x, FL_Coord y, 
12084                 FL_Coord w, FL_Coord h, const char * label, 
12085                 FL_HANDLEPTR handle) 
12086              """) 
12087      check_admitted_listvalues(freetype, FREETYPE_list) 
12088      ifreetype = convert_to_int(freetype) 
12089      ix = convert_to_FL_Coord(x) 
12090      iy = convert_to_FL_Coord(y) 
12091      iw = convert_to_FL_Coord(w) 
12092      ih = convert_to_FL_Coord(h) 
12093      slabel = convert_to_string(label) 
12094      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
12095      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
12096      keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 
12097                     slabel) 
12098      retval = _fl_create_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 
12099      return retval 
12100   
12101   
12102 -def fl_add_free(freetype, x, y, w, h, label, py_HandlePtr): 
12103      """ fl_add_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 
12104      """ 
12105   
12106      _fl_add_free = cfuncproto( 
12107              load_so_libforms(), "fl_add_free", 
12108              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
12109              FL_Coord, STRING, FL_HANDLEPTR], 
12110              """FL_OBJECT * fl_add_free(int type, FL_Coord x, FL_Coord y, 
12111                 FL_Coord w, FL_Coord h, const char * label, 
12112                 FL_HANDLEPTR handle) 
12113              """) 
12114      check_admitted_listvalues(freetype, FREETYPE_list) 
12115      ifreetype = convert_to_int(freetype) 
12116      ix = convert_to_FL_Coord(x) 
12117      iy = convert_to_FL_Coord(y) 
12118      iw = convert_to_FL_Coord(w) 
12119      ih = convert_to_FL_Coord(h) 
12120      slabel = convert_to_string(label) 
12121      c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 
12122      keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 
12123      keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 
12124                     slabel) 
12125      retval = _fl_add_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 
12126      return retval 
12127   
12128   
12129   
12130  ###################### 
12131  # forms.h (goodies.h) 
12132  ###################### 
12133   
12134  # Resources and misc. goodie routines 
12135   
12136 -def fl_set_goodies_font(style, size): 
12137      """ fl_set_goodies_font(style, size) 
12138      """ 
12139   
12140      _fl_set_goodies_font = cfuncproto( 
12141              load_so_libforms(), "fl_set_goodies_font", 
12142              None, [cty.c_int, cty.c_int], 
12143              """void fl_set_goodies_font(int style, int size) 
12144              """) 
12145      istyle = convert_to_int(style) 
12146      isize = convert_to_int(size) 
12147      keep_elem_refs(style, size, istyle, isize) 
12148      _fl_set_goodies_font(istyle, isize) 
12149   
12150   
12151  # messages and questions 
12152   
12153 -def fl_show_message(msgtxt1, msgtxt2, msgtxt3): 
12154      """ 
12155          fl_show_message(msgtxt1, msgtxt2, msgtxt3) 
12156   
12157          Shows a message. 
12158   
12159          @param msgtxt1 : first message to show 
12160          @param msgtxt2 : second message to show 
12161          @param msgtxt3 : third message to show 
12162      """ 
12163   
12164      _fl_show_message = cfuncproto( 
12165              load_so_libforms(), "fl_show_message", 
12166              None, [STRING, STRING, STRING], 
12167              """void fl_show_message(const char * p1, const char * p2, 
12168                 const char * p3) 
12169              """) 
12170      smsgtxt1 = convert_to_string(msgtxt1) 
12171      smsgtxt2 = convert_to_string(msgtxt2) 
12172      smsgtxt3 = convert_to_string(msgtxt3) 
12173      keep_elem_refs(msgtxt1, msgtxt2, msgtxt3, smsgtxt1, smsgtxt2, smsgtxt3) 
12174      _fl_show_message(smsgtxt1, smsgtxt2, smsgtxt3) 
12175   
12176   
12177 -def fl_show_messages(p1): 
12178      """ fl_show_messages(p1) 
12179      """ 
12180   
12181      _fl_show_messages = cfuncproto( 
12182              load_so_libforms(), "fl_show_messages", 
12183              None, [STRING], 
12184              """void fl_show_messages(const char * p1) 
12185              """) 
12186      sp1 = convert_to_string(p1) 
12187      keep_elem_refs(p1, sp1) 
12188      _fl_show_messages(sp1) 
12189   
12190   
12191 -def fl_show_msg(fmttxt): 
12192      """ 
12193          fl_show_msg(fmttxt) 
12194   
12195          Shows a text message. 
12196   
12197          @param fmttxt : text message to show (with format parameters, e.g. 
12198             %s, %d, %f etc..) 
12199      """ 
12200   
12201      _fl_show_msg = cfuncproto( 
12202              load_so_libforms(), "fl_show_msg", 
12203              None, [STRING], 
12204              """void fl_show_msg(const char * p1) 
12205              """) 
12206      sfmttxt = convert_to_string(fmttxt) 
12207      keep_elem_refs(fmttxt, sfmttxt) 
12208      _fl_show_msg(sfmttxt) 
12209   
12210   
12211 -def fl_hide_message(): 
12212      """ 
12213          fl_hide_message() 
12214   
12215          Hides a text message already shown. 
12216      """ 
12217   
12218      _fl_hide_message = cfuncproto( 
12219              load_so_libforms(), "fl_hide_message", 
12220              None, [], 
12221              """void fl_hide_message() 
12222              """) 
12223      _fl_hide_message() 
12224   
12225   
12226  fl_hide_msg = fl_hide_message 
12227  fl_hide_messages = fl_hide_message 
12228   
12229   
12230 -def fl_show_question(questmsg, p2): 
12231      """ 
12232          fl_show_question(questmsg, p2) -> num. 
12233   
12234          Shows a question message. 
12235   
12236          @param questmsg : text of question message to show 
12237          @param p2 : ? 
12238      """ 
12239   
12240      _fl_show_question = cfuncproto( 
12241              load_so_libforms(), "fl_show_question", 
12242              cty.c_int, [STRING, cty.c_int], 
12243              """int fl_show_question(const char * p1, int p2) 
12244              """) 
12245      squestmsg = convert_to_string(questmsg) 
12246      ip2 = convert_to_int(p2) 
12247      keep_elem_refs(questmsg, p2, squestmsg, ip2) 
12248      retval = _fl_show_question(squestmsg, ip2) 
12249      return retval 
12250   
12251   
12252 -def fl_hide_question(): 
12253      """ 
12254          fl_hide_question() 
12255   
12256          Hides a question message already shown. 
12257      """ 
12258   
12259      _fl_hide_question = cfuncproto( 
12260              load_so_libforms(), "fl_hide_question", 
12261              None, [], 
12262              """void fl_hide_question() 
12263              """) 
12264      _fl_hide_question() 
12265   
12266   
12267 -def fl_show_alert(p1, p2, p3, p4): 
12268      """ fl_show_alert(p1, p2, p3, p4) 
12269      """ 
12270   
12271      _fl_show_alert = cfuncproto( 
12272              load_so_libforms(), "fl_show_alert", 
12273              None, [STRING, STRING, STRING, cty.c_int], 
12274              """void fl_show_alert(const char * p1, const char * p2, 
12275                 const char * p3, int p4) 
12276              """) 
12277      sp1 = convert_to_string(p1) 
12278      sp2 = convert_to_string(p2) 
12279      sp3 = convert_to_string(p3) 
12280      ip4 = convert_to_int(p4) 
12281      keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 
12282      _fl_show_alert(sp1, sp2, sp3, ip4) 
12283   
12284   
12285 -def fl_show_alert2(c, fmt): 
12286      """ fl_show_alert2(c, fmt) 
12287      """ 
12288   
12289      _fl_show_alert2 = cfuncproto( 
12290              load_so_libforms(), "fl_show_alert2", 
12291              None, [cty.c_int, STRING], 
12292              """void fl_show_alert2(int c, const char * fmt) 
12293              """) 
12294      ic = convert_to_int(c) 
12295      sfmt = convert_to_string(fmt) 
12296      keep_elem_refs(c, fmt, ic, sfmt) 
12297      _fl_show_alert2(ic, sfmt) 
12298   
12299   
12300 -def fl_hide_alert(): 
12301      """ fl_hide_alert() 
12302      """ 
12303   
12304      _fl_hide_alert = cfuncproto( 
12305              load_so_libforms(), "fl_hide_alert", 
12306              None, [], 
12307              """void fl_hide_alert() 
12308              """) 
12309      _fl_hide_alert() 
12310   
12311   
12312 -def fl_show_input(p1, p2): 
12313      """ fl_show_input(p1, p2) -> input string 
12314      """ 
12315   
12316      _fl_show_input = cfuncproto( 
12317              load_so_libforms(), "fl_show_input", 
12318              STRING, [STRING, STRING], 
12319              """const char * fl_show_input(const char * p1, const char * p2) 
12320              """) 
12321      sp1 = convert_to_string(p1) 
12322      sp2 = convert_to_string(p2) 
12323      keep_elem_refs(p1, p2, sp1, sp2) 
12324      retval = _fl_show_input(sp1, sp2) 
12325      return retval 
12326   
12327   
12328 -def fl_hide_input(): 
12329      """ fl_hide_input() 
12330      """ 
12331   
12332      _fl_hide_input = cfuncproto( 
12333              load_so_libforms(), "fl_hide_input", 
12334              None, [], 
12335              """void fl_hide_input() 
12336              """) 
12337      _fl_hide_input() 
12338   
12339   
12340 -def fl_show_simple_input(msgtxt, defstr): 
12341      """ 
12342          fl_show_simple_input(msgtxt, defstr) -> input string 
12343   
12344          Asks the user for textual input. 
12345   
12346          @param msgtxt : text message 
12347          @param defstr : default user answer in input 
12348      """ 
12349   
12350      _fl_show_simple_input = cfuncproto( 
12351              load_so_libforms(), "fl_show_simple_input", 
12352              STRING, [STRING, STRING], 
12353              """const char * fl_show_simple_input(const char * p1, 
12354                 const char * p2) 
12355              """) 
12356      smsgtxt = convert_to_string(msgtxt) 
12357      sdefstr = convert_to_string(defstr) 
12358      keep_elem_refs(msgtxt, defstr, smsgtxt, sdefstr) 
12359      retval = _fl_show_simple_input(smsgtxt, sdefstr) 
12360      return retval 
12361   
12362   
12363 -def fl_show_colormap(oldcolr): 
12364      """ fl_show_colormap(oldcolr) -> colormap num. 
12365          Shows a colormap color selector from which the user can select a color. 
12366          <oldcolr> : color num. 
12367      """ 
12368   
12369      _fl_show_colormap = cfuncproto( 
12370              load_so_libforms(), "fl_show_colormap", 
12371              cty.c_int, [cty.c_int], 
12372              """int fl_show_colormap(int p1) 
12373              """) 
12374      ioldcolr = convert_to_int(oldcolr) 
12375      keep_elem_refs(oldcolr, ioldcolr) 
12376      retval = _fl_show_colormap(ioldcolr) 
12377      return retval 
12378   
12379   
12380  # choices 
12381   
12382 -def fl_show_choices(p1, p2, p3, p4, p5, p6): 
12383      """ fl_show_choices(p1, p2, p3, p4, p5, p6) -> num. 
12384      """ 
12385   
12386      _fl_show_choices = cfuncproto( 
12387              load_so_libforms(), "fl_show_choices", 
12388              cty.c_int, [STRING, cty.c_int, STRING, STRING, STRING, 
12389              cty.c_int], 
12390              """int fl_show_choices(const char * p1, int p2, 
12391                 const char * p3, const char * p4, const char * p5, int p6) 
12392              """) 
12393      sp1 = convert_to_string(p1) 
12394      ip2 = convert_to_int(p2) 
12395      sp3 = convert_to_string(p3) 
12396      sp4 = convert_to_string(p4) 
12397      sp5 = convert_to_string(p5) 
12398      ip6 = convert_to_int(p6) 
12399      keep_elem_refs(p1, p2, p3, p4, p5, p6, sp1, ip2, sp3, sp4, sp5, ip6) 
12400      retval = _fl_show_choices(sp1, ip2, sp3, sp4, sp5, ip6) 
12401      return retval 
12402   
12403   
12404 -def fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8): 
12405      """ fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8) -> num. 
12406      """ 
12407   
12408      _fl_show_choice = cfuncproto( 
12409              load_so_libforms(), "fl_show_choice", 
12410              cty.c_int, [STRING, STRING, STRING, cty.c_int, STRING, STRING, 
12411              STRING, cty.c_int], 
12412              """int fl_show_choice(const char * p1, const char * p2, 
12413                 const char * p3, int p4, const char * p5, const char * p6, 
12414                 const char * p7, int p8) 
12415              """) 
12416      sp1 = convert_to_string(p1) 
12417      sp2 = convert_to_string(p2) 
12418      sp3 = convert_to_string(p3) 
12419      ip4 = convert_to_int(p4) 
12420      sp5 = convert_to_string(p5) 
12421      sp6 = convert_to_string(p6) 
12422      sp7 = convert_to_string(p7) 
12423      ip8 = convert_to_int(p8) 
12424      keep_elem_refs(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 
12425      retval = _fl_show_choice(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 
12426      return retval 
12427   
12428   
12429 -def fl_hide_choice(): 
12430      """ fl_hide_choice() 
12431      """ 
12432   
12433      _fl_hide_choice = cfuncproto( 
12434              load_so_libforms(), "fl_hide_choice", 
12435              None, [], 
12436              """void fl_hide_choice() 
12437              """) 
12438      _fl_hide_choice() 
12439   
12440   
12441 -def fl_set_choices_shortcut(p1, p2, p3): 
12442      """ fl_set_choices_shortcut(p1, p2, p3) 
12443      """ 
12444   
12445      _fl_set_choices_shortcut = cfuncproto( 
12446              load_so_libforms(), "fl_set_choices_shortcut", 
12447              None, [STRING, STRING, STRING], 
12448              """void fl_set_choices_shortcut(const char * p1, const char * p2, 
12449                 const char * p3) 
12450              """) 
12451      sp1 = convert_to_string(p1) 
12452      sp2 = convert_to_string(p2) 
12453      sp3 = convert_to_string(p3) 
12454      keep_elem_refs(p1, p2, p3, sp1, sp2, sp3) 
12455      _fl_set_choices_shortcut(sp1, sp2, sp3) 
12456   
12457   
12458  fl_set_choice_shortcut = fl_set_choices_shortcut 
12459   
12460   
12461  # one liner 
12462   
12463 -def fl_show_oneliner(p1, p2, p3): 
12464      """ fl_show_oneliner(p1, p2, p3) 
12465      """ 
12466   
12467      _fl_show_oneliner = cfuncproto( 
12468              load_so_libforms(), "fl_show_oneliner", 
12469              None, [STRING, FL_Coord, FL_Coord], 
12470              """void fl_show_oneliner(const char * p1, FL_Coord p2, 
12471                 FL_Coord p3) 
12472              """) 
12473      sp1 = convert_to_string(p1) 
12474      ip2 = convert_to_FL_Coord(p2) 
12475      ip3 = convert_to_FL_Coord(p3) 
12476      keep_elem_refs(p1, p2, p3, sp1, ip2, ip3) 
12477      _fl_show_oneliner(sp1, ip2, ip3) 
12478   
12479   
12480 -def fl_hide_oneliner(): 
12481      """ fl_hide_oneliner() 
12482      """ 
12483   
12484      _fl_hide_oneliner = cfuncproto( 
12485              load_so_libforms(), "fl_hide_oneliner", 
12486              None, [], 
12487              """void fl_hide_oneliner() 
12488              """) 
12489      _fl_hide_oneliner() 
12490   
12491   
12492 -def fl_set_oneliner_font(p1, p2): 
12493      """ fl_set_oneliner_font(p1, p2) 
12494      """ 
12495   
12496      _fl_set_oneliner_font = cfuncproto( 
12497              load_so_libforms(), "fl_set_oneliner_font", 
12498              None, [cty.c_int, cty.c_int], 
12499              """void fl_set_oneliner_font(int p1, int p2) 
12500              """) 
12501      ip1 = convert_to_int(p1) 
12502      ip2 = convert_to_int(p2) 
12503      keep_elem_refs(p1, p2, ip1, ip2) 
12504      _fl_set_oneliner_font(ip1, ip2) 
12505   
12506   
12507 -def fl_set_oneliner_color(p1, p2): 
12508      """ fl_set_oneliner_color(p1, p2) 
12509      """ 
12510   
12511      _fl_set_oneliner_color = cfuncproto( 
12512              load_so_libforms(), "fl_set_oneliner_color", 
12513              None, [FL_COLOR, FL_COLOR], 
12514              """void fl_set_oneliner_color(FL_COLOR p1, FL_COLOR p2) 
12515              """) 
12516      ulp1 = convert_to_FL_COLOR(p1) 
12517      ulp2 = convert_to_FL_COLOR(p2) 
12518      keep_elem_refs(p1, p2, ulp1, ulp2) 
12519      _fl_set_oneliner_color(ulp1, ulp2) 
12520   
12521   
12522 -def fl_set_tooltip_font(p1, p2): 
12523      """ fl_set_tooltip_font(p1, p2) 
12524      """ 
12525   
12526      _fl_set_tooltip_font = cfuncproto( 
12527              load_so_libforms(), "fl_set_tooltip_font", 
12528              None, [cty.c_int, cty.c_int], 
12529              """void fl_set_tooltip_font(int p1, int p2) 
12530              """) 
12531      ip1 = convert_to_int(p1) 
12532      ip2 = convert_to_int(p2) 
12533      keep_elem_refs(p1, p2, ip1, ip2) 
12534      _fl_set_tooltip_font(ip1, ip2) 
12535   
12536   
12537 -def fl_set_tooltip_color(p1, p2): 
12538      """ fl_set_tooltip_color(p1, p2) 
12539      """ 
12540   
12541      _fl_set_tooltip_color = cfuncproto( 
12542              load_so_libforms(), "fl_set_tooltip_color", 
12543              None, [FL_COLOR, FL_COLOR], 
12544              """void fl_set_tooltip_color(FL_COLOR p1, FL_COLOR p2) 
12545              """) 
12546      ulp1 = convert_to_FL_COLOR(p1) 
12547      ulp2 = convert_to_FL_COLOR(p2) 
12548      keep_elem_refs(p1, p2, ulp1, ulp2) 
12549      _fl_set_tooltip_color(ulp1, ulp2) 
12550   
12551   
12552 -def fl_set_tooltip_boxtype(p1): 
12553      """ fl_set_tooltip_boxtype(p1) 
12554      """ 
12555   
12556      _fl_set_tooltip_boxtype = cfuncproto( 
12557              load_so_libforms(), "fl_set_tooltip_boxtype", 
12558              None, [cty.c_int], 
12559              """void fl_set_tooltip_boxtype(int p1) 
12560              """) 
12561      ip1 = convert_to_int(p1) 
12562      keep_elem_refs(p1, ip1) 
12563      _fl_set_tooltip_boxtype(ip1) 
12564   
12565   
12566 -def fl_set_tooltip_lalign(p1): 
12567      """ fl_set_tooltip_lalign(p1) 
12568      """ 
12569   
12570      _fl_set_tooltip_lalign = cfuncproto( 
12571              load_so_libforms(), "fl_set_tooltip_lalign", 
12572              None, [cty.c_int], 
12573              """void fl_set_tooltip_lalign(int p1) 
12574              """) 
12575      ip1 = convert_to_int(p1) 
12576      keep_elem_refs(p1, ip1) 
12577      _fl_set_tooltip_lalign(ip1) 
12578   
12579   
12580 -def fl_exe_command(p1, p2): 
12581      """ fl_exe_command(p1, p2) -> num. 
12582      """ 
12583   
12584      _fl_exe_command = cfuncproto( 
12585              load_so_libforms(), "fl_exe_command", 
12586              cty.c_long, [STRING, cty.c_int], 
12587              """long int fl_exe_command(const char * p1, int p2) 
12588              """) 
12589      sp1 = convert_to_string(p1) 
12590      ip2 = convert_to_int(p2) 
12591      keep_elem_refs(p1, sp1, p2, ip2) 
12592      retval = _fl_exe_command(sp1, ip2) 
12593      return retval 
12594   
12595   
12596 -def fl_end_command(p1): 
12597      """ fl_end_command(p1) -> num. 
12598      """ 
12599   
12600      _fl_end_command = cfuncproto( 
12601              load_so_libforms(), "fl_end_command", 
12602              cty.c_int, [cty.c_long], 
12603              """int fl_end_command(long int p1) 
12604              """) 
12605      lp1 = convert_to_long(p1) 
12606      keep_elem_refs(p1, lp1) 
12607      retval = _fl_end_command(lp1) 
12608      return retval 
12609   
12610   
12611 -def fl_check_command(p1): 
12612      """ fl_check_command(p1) -> num. 
12613      """ 
12614   
12615      _fl_check_command = cfuncproto( 
12616              load_so_libforms(), "fl_check_command", 
12617              cty.c_int, [cty.c_long], 
12618              """int fl_check_command(long int p1) 
12619              """) 
12620      lp1 = convert_to_long(p1) 
12621      keep_elem_refs(p1, lp1) 
12622      retval = _fl_check_command(lp1) 
12623      return retval 
12624   
12625   
12626 -def fl_popen(p1, p2): 
12627      """ fl_popen(p1, p2) -> FILE ptr. 
12628      """ 
12629   
12630      _fl_popen = cfuncproto( 
12631              load_so_libforms(), "fl_popen", 
12632              cty.POINTER(FILE), [STRING, STRING], 
12633              """FILE * fl_popen(const char * p1, const char * p2) 
12634              """) 
12635      sp1 = convert_to_string(p1) 
12636      sp2 = convert_to_string(p2) 
12637      keep_elem_refs(p1, p2, sp1, sp2) 
12638      retval = _fl_popen(sp1, sp2) 
12639      return retval 
12640   
12641   
12642 -def fl_pclose(p1): 
12643      """ fl_pclose(p1) -> num. 
12644      """ 
12645   
12646      _fl_pclose = cfuncproto( 
12647              load_so_libforms(), "fl_pclose", 
12648              cty.c_int, [cty.POINTER(FILE)], 
12649              """int fl_pclose(FILE * p1) 
12650              """) 
12651      keep_elem_refs(p1) 
12652      retval = _fl_pclose(p1) 
12653      return retval 
12654   
12655   
12656 -def fl_end_all_command(): 
12657      """ fl_end_all_command() -> num. 
12658      """ 
12659   
12660      _fl_end_all_command = cfuncproto( 
12661              load_so_libforms(), "fl_end_all_command", 
12662              cty.c_int, [], 
12663              """int fl_end_all_command() 
12664              """) 
12665      retval = _fl_end_all_command() 
12666      return retval 
12667   
12668   
12669 -def fl_show_command_log(p1): 
12670      """ fl_show_command_log(p1) 
12671      """ 
12672   
12673      _fl_show_command_log = cfuncproto( 
12674              load_so_libforms(), "fl_show_command_log", 
12675              None, [cty.c_int], 
12676              """void fl_show_command_log(int p1) 
12677              """) 
12678      ip1 = convert_to_int(p1) 
12679      keep_elem_refs(p1, ip1) 
12680      _fl_show_command_log(ip1) 
12681   
12682   
12683 -def fl_hide_command_log(): 
12684      """ fl_hide_command_log() 
12685      """ 
12686   
12687      _fl_hide_command_log = cfuncproto( 
12688              load_so_libforms(), "fl_hide_command_log", 
12689              None, [], 
12690              """void fl_hide_command_log() 
12691              """) 
12692      _fl_hide_command_log() 
12693   
12694   
12695 -def fl_clear_command_log(): 
12696      """ fl_clear_command_log() 
12697      """ 
12698   
12699      _fl_clear_command_log = cfuncproto( 
12700              load_so_libforms(), "fl_clear_command_log", 
12701              None, [], 
12702              """void fl_clear_command_log() 
12703              """) 
12704      _fl_clear_command_log() 
12705   
12706   
12707 -def fl_addto_command_log(p1): 
12708      """ fl_addto_command_log(p1) 
12709      """ 
12710   
12711      _fl_addto_command_log = cfuncproto( 
12712              load_so_libforms(), "fl_addto_command_log", 
12713              None, [STRING], 
12714              """void fl_addto_command_log(const char * p1) 
12715              """) 
12716      sp1 = convert_to_string(p1) 
12717      keep_elem_refs(p1, sp1) 
12718      _fl_addto_command_log(sp1) 
12719   
12720   
12721 -def fl_set_command_log_position(p1, p2): 
12722      """ fl_set_command_log_position(p1, p2) 
12723      """ 
12724   
12725      _fl_set_command_log_position = cfuncproto( 
12726              load_so_libforms(), "fl_set_command_log_position", 
12727              None, [cty.c_int, cty.c_int], 
12728              """void fl_set_command_log_position(int p1, int p2) 
12729              """) 
12730      ip1 = convert_to_int(p1) 
12731      ip2 = convert_to_int(p2) 
12732      keep_elem_refs(p1, p2, ip1, ip2) 
12733      _fl_set_command_log_position(ip1, ip2) 
12734   
12735   
12736 -def fl_get_command_log_fdstruct(): 
12737      """ fl_get_command_log_fdstruct() -> pCmdlog 
12738      """ 
12739   
12740      _fl_get_command_log_fdstruct = cfuncproto( 
12741              load_so_libforms(), "fl_get_command_log_fdstruct", 
12742              cty.POINTER(FD_CMDLOG), [], 
12743              """)FD_CMDLOG * fl_get_command_log_fdstruct() 
12744              """) 
12745      retval = _fl_get_command_log_fdstruct() 
12746      return retval 
12747   
12748   
12749  # aliases 
12750  fl_open_command = fl_exe_command 
12751  fl_close_command = fl_end_command 
12752   
12753   
12754  # file selector 
12755   
12756 -def fl_use_fselector(p1): 
12757      """ fl_use_fselector(p1) -> num. 
12758      """ 
12759   
12760      _fl_use_fselector = cfuncproto( 
12761              load_so_libforms(), "fl_use_fselector", 
12762              cty.c_int, [cty.c_int], 
12763              """int fl_use_fselector(int p1) 
12764              """) 
12765      ip1 = convert_to_int(p1) 
12766      keep_elem_refs(p1, ip1) 
12767      retval = _fl_use_fselector(ip1) 
12768      return retval 
12769   
12770   
12771 -def fl_show_fselector(p1, p2, p3, p4): 
12772      """ fl_show_fselector(p1, p2, p3, p4) -> fselector string 
12773      """ 
12774   
12775      _fl_show_fselector = cfuncproto( 
12776              load_so_libforms(), "fl_show_fselector", 
12777              STRING, [STRING, STRING, STRING, STRING], 
12778              """const char * fl_show_fselector(const char * p1, 
12779                 const char * p2, const char * p3, const char * p4) 
12780              """) 
12781      sp1 = convert_to_string(p1) 
12782      sp2 = convert_to_string(p2) 
12783      sp3 = convert_to_string(p3) 
12784      sp4 = convert_to_string(p4) 
12785      keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, sp4) 
12786      retval = _fl_show_fselector(sp1, sp2, sp3, sp4) 
12787      return retval 
12788   
12789   
12790 -def fl_set_fselector_fontsize(p1): 
12791      """ fl_set_fselector_fontsize(p1) 
12792      """ 
12793   
12794      _fl_set_fselector_fontsize = cfuncproto( 
12795              load_so_libforms(), "fl_set_fselector_fontsize", 
12796              None, [cty.c_int], 
12797              """void fl_set_fselector_fontsize(int p1) 
12798              """) 
12799      ip1 = convert_to_int(p1) 
12800      keep_elem_refs(p1, ip1) 
12801      _fl_set_fselector_fontsize(ip1) 
12802   
12803   
12804 -def fl_set_fselector_fontstyle(p1): 
12805      """ fl_set_fselector_fontstyle(p1) 
12806      """ 
12807   
12808      _fl_set_fselector_fontstyle = cfuncproto( 
12809              load_so_libforms(), "fl_set_fselector_fontstyle", 
12810              None, [cty.c_int], 
12811              """void fl_set_fselector_fontstyle(int p1) 
12812              """) 
12813      ip1 = convert_to_int(p1) 
12814      keep_elem_refs(p1, ip1) 
12815      _fl_set_fselector_fontstyle(ip1) 
12816   
12817   
12818 -def fl_set_fselector_placement(p1): 
12819      """ fl_set_fselector_placement(p1) 
12820      """ 
12821   
12822      _fl_set_fselector_placement = cfuncproto( 
12823              load_so_libforms(), "fl_set_fselector_placement", 
12824              None, [cty.c_int], 
12825              """void fl_set_fselector_placement(int p1) 
12826              """) 
12827      ip1 = convert_to_int(p1) 
12828      keep_elem_refs(p1, ip1) 
12829      _fl_set_fselector_placement(ip1) 
12830   
12831   
12832 -def fl_set_fselector_border(p1): 
12833      """ fl_set_fselector_border(p1) 
12834      """ 
12835   
12836      _fl_set_fselector_border = cfuncproto( 
12837              load_so_libforms(), "fl_set_fselector_border", 
12838              None, [cty.c_int], 
12839              """void fl_set_fselector_border(int p1) 
12840              """) 
12841      ip1 = convert_to_int(p1) 
12842      keep_elem_refs(p1, ip1) 
12843      _fl_set_fselector_border(ip1) 
12844   
12845   
12846 -def fl_set_fselector_transient(b): 
12847      if b: 
12848          argval = FL_TRANSIENT 
12849      else: 
12850          argval = FL_FULLBORDER 
12851      fl_set_fselector_border(argval) 
12852   
12853   
12854  FL_FSCB = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_void_p) 
12855   
12856 -def fl_set_fselector_callback(py_FSCB, data): 
12857      """ 
12858          fl_set_fselector_callback(py_FSCB, data) 
12859      """ 
12860   
12861      _fl_set_fselector_callback = cfuncproto( 
12862              load_so_libforms(), "fl_set_fselector_callback", 
12863              None, [FL_FSCB, cty.c_void_p], 
12864              """void fl_set_fselector_callback(FL_FSCB p1, void * p2) 
12865              """) 
12866      c_FSCB = FL_FSCB(py_FSCB) 
12867      pdata = cty.cast(data, cty.c_void_p) 
12868      keep_cfunc_refs(c_FSCB, py_FSCB) 
12869      keep_elem_refs(data, pdata) 
12870      _fl_set_fselector_callback(c_FSCB, pdata) 
12871   
12872   
12873 -def fl_get_filename(): 
12874      """ fl_get_filename() -> filename string 
12875      """ 
12876   
12877      _fl_get_filename = cfuncproto( 
12878              load_so_libforms(), "fl_get_filename", 
12879              STRING, [], 
12880              """const char * fl_get_filename() 
12881              """) 
12882      retval = _fl_get_filename() 
12883      return retval 
12884   
12885   
12886 -def fl_get_directory(): 
12887      """ fl_get_directory() -> directory string 
12888      """ 
12889   
12890      _fl_get_directory = cfuncproto( 
12891              load_so_libforms(), "fl_get_directory", 
12892              STRING, [], 
12893              """const char * fl_get_directory() 
12894              """) 
12895      retval = _fl_get_directory() 
12896      return retval 
12897   
12898   
12899 -def fl_get_pattern(): 
12900      """ fl_get_pattern() -> pattern string 
12901      """ 
12902   
12903      _fl_get_pattern = cfuncproto( 
12904              load_so_libforms(), "fl_get_pattern", 
12905              STRING, [], 
12906              """const char * fl_get_pattern() 
12907              """) 
12908      retval = _fl_get_pattern() 
12909      return retval 
12910   
12911   
12912 -def fl_set_directory(p1): 
12913      """ fl_set_directory(p1) -> num. 
12914      """ 
12915   
12916      _fl_set_directory = cfuncproto( 
12917              load_so_libforms(), "fl_set_directory", 
12918              cty.c_int, [STRING], 
12919              """int fl_set_directory(const char * p1) 
12920              """) 
12921      sp1 = convert_to_string(p1) 
12922      keep_elem_refs(p1, sp1) 
12923      retval = _fl_set_directory(sp1) 
12924      return retval 
12925   
12926   
12927 -def fl_set_pattern(p1): 
12928      """ fl_set_pattern(p1) 
12929      """ 
12930   
12931      _fl_set_pattern = cfuncproto( 
12932              load_so_libforms(), "fl_set_pattern", 
12933              None, [STRING], 
12934              """void fl_set_pattern(const char * p1) 
12935              """) 
12936      sp1 = convert_to_string(p1) 
12937      keep_elem_refs(p1, sp1) 
12938      _fl_set_pattern(sp1) 
12939   
12940   
12941 -def fl_refresh_fselector(): 
12942      """ fl_refresh_fselector() 
12943      """ 
12944   
12945      _fl_refresh_fselector = cfuncproto( 
12946              load_so_libforms(), "fl_refresh_fselector", 
12947              None, [], 
12948              """void fl_refresh_fselector() 
12949              """) 
12950      _fl_refresh_fselector() 
12951   
12952   
12953  # c function prototype for _fl_add_fselector_appbutton 
12954  cfunc_none_voidp = cty.CFUNCTYPE(None, cty.c_void_p) 
12955   
12956 -def fl_add_fselector_appbutton(label, py_fn, data): 
12957      """ fl_add_fselector_appbutton(label, py_fn, data) 
12958      """ 
12959   
12960      _fl_add_fselector_appbutton = cfuncproto( 
12961              load_so_libforms(), "fl_add_fselector_appbutton", 
12962              None, [STRING, cfunc_none_voidp, cty.c_void_p], 
12963              """void fl_add_fselector_appbutton(const char * p1, 
12964                 const char * p2, void * p3) 
12965              """) 
12966      slabel = convert_to_string(label) 
12967      c_fn = cfunc_none_voidp(py_fn) 
12968      pdata = cty.cast(data, cty.c_void_p) 
12969      keep_cfunc_refs(c_fn, py_fn) 
12970      keep_elem_refs(label, data, slabel, pdata) 
12971      _fl_add_fselector_appbutton(slabel, c_fn, pdata) 
12972   
12973   
12974 -def fl_remove_fselector_appbutton(label): 
12975      """ fl_remove_fselector_appbutton(label) 
12976      """ 
12977   
12978      _fl_remove_fselector_appbutton = cfuncproto( 
12979              load_so_libforms(), "fl_remove_fselector_appbutton", 
12980              None, [STRING], 
12981              """void fl_remove_fselector_appbutton(const char * p1) 
12982              """) 
12983      slabel = convert_to_string(label) 
12984      keep_elem_refs(label, slabel) 
12985      _fl_remove_fselector_appbutton(slabel) 
12986   
12987   
12988 -def fl_disable_fselector_cache(yes): 
12989      """ fl_disable_fselector_cache(yes) 
12990      """ 
12991   
12992      _fl_disable_fselector_cache = cfuncproto( 
12993              load_so_libforms(), "fl_disable_fselector_cache", 
12994              None, [cty.c_int], 
12995              """void fl_disable_fselector_cache(int p1) 
12996              """) 
12997      iyes = convert_to_int(yes) 
12998      keep_elem_refs(yes, iyes) 
12999      _fl_disable_fselector_cache(iyes) 
13000   
13001   
13002 -def fl_invalidate_fselector_cache(): 
13003      """ fl_invalidate_fselector_cache() 
13004      """ 
13005   
13006      _fl_invalidate_fselector_cache = cfuncproto( 
13007              load_so_libforms(), "fl_invalidate_fselector_cache", 
13008              None, [], 
13009              """void fl_invalidate_fselector_cache() 
13010              """) 
13011      _fl_invalidate_fselector_cache() 
13012   
13013   
13014 -def fl_get_fselector_form(): 
13015      """ fl_get_fselector_form() -> pForm 
13016      """ 
13017   
13018      _fl_get_fselector_form = cfuncproto( 
13019              load_so_libforms(), "fl_get_fselector_form", 
13020              cty.POINTER(FL_FORM), [], 
13021              """FL_FORM * fl_get_fselector_form() 
13022              """) 
13023      retval = _fl_get_fselector_form() 
13024      return retval 
13025   
13026   
13027 -def fl_get_fselector_fdstruct(): 
13028      """ fl_get_fselector_fdstruct() -> fselector class 
13029      """ 
13030   
13031      _fl_get_fselector_fdstruct = cfuncproto( 
13032              load_so_libforms(), "fl_get_fselector_fdstruct", 
13033              cty.POINTER(FD_FSELECTOR), [], 
13034              """FD_FSELECTOR * fl_get_fselector_fdstruct() 
13035              """) 
13036      retval = _fl_get_fselector_fdstruct() 
13037      return retval 
13038   
13039   
13040 -def fl_hide_fselector(): 
13041      """ fl_hide_fselector() 
13042      """ 
13043   
13044      _fl_hide_fselector = cfuncproto( 
13045              load_so_libforms(), "fl_hide_fselector", 
13046              None, [], 
13047              """void fl_hide_fselector() 
13048              """) 
13049      _fl_hide_fselector() 
13050   
13051   
13052 -def fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5): 
13053      """ fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5) 
13054      """ 
13055   
13056      _fl_set_fselector_filetype_marker = cfuncproto( 
13057              load_so_libforms(), "fl_set_fselector_filetype_marker", 
13058              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int], 
13059              """void fl_set_fselector_filetype_marker(int p1, int p2, int p3, 
13060                 int p4, int p5) 
13061              """) 
13062      ip1 = convert_to_int(p1) 
13063      ip2 = convert_to_int(p2) 
13064      ip3 = convert_to_int(p3) 
13065      ip4 = convert_to_int(p4) 
13066      ip5 = convert_to_int(p5) 
13067      keep_elem_refs(p1, p2, p3, p4, p5, ip1, ip2, ip3, ip4, ip5) 
13068      _fl_set_fselector_filetype_marker(ip1, ip2, ip3, ip4, ip5) 
13069   
13070   
13071  fl_show_file_selector = fl_show_fselector 
13072  fl_set_fselector_cb = fl_set_fselector_callback 
13073   
13074   
13075 -def fl_set_fselector_title(title): 
13076      fl_set_form_title(fl_get_fselector_form(), title) 
13077   
13078   
13079 -def fl_goodies_atclose(pForm, data): 
13080      """ fl_goodies_atclose(pForm, data) -> num. 
13081      """ 
13082   
13083      _fl_goodies_atclose = cfuncproto( 
13084              load_so_libforms(), "fl_goodies_atclose", 
13085              cty.c_int, [cty.POINTER(FL_FORM), cty.c_void_p], 
13086              """int fl_goodies_atclose(FL_FORM * p1, void * p2) 
13087              """) 
13088      pdata = cty.cast(data, cty.c_void_p) 
13089      keep_elem_refs(pForm, data, pdata) 
13090      retval = _fl_goodies_atclose(pForm, pdata) 
13091      return retval 
13092   
13093   
13094   
13095  #################### 
13096  # forms.h (input.h) 
13097  #################### 
13098   
13099  # Routines 
13100   
13101 -def fl_create_input(inputtype, x, y, w, h, label): 
13102      """ fl_create_input(inputtype, x, y, w, h, label) -> pObject 
13103      """ 
13104   
13105      _fl_create_input = cfuncproto( 
13106              load_so_libforms(), "fl_create_input", 
13107              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13108              FL_Coord, STRING], 
13109              """FL_OBJECT * fl_create_input(int type, FL_Coord x, FL_Coord y, 
13110                 FL_Coord w, FL_Coord h, const char * label) 
13111              """) 
13112      check_admitted_listvalues(inputtype, INPUTTYPE_list) 
13113      iinputtype = convert_to_int(inputtype) 
13114      ix = convert_to_FL_Coord(x) 
13115      iy = convert_to_FL_Coord(y) 
13116      iw = convert_to_FL_Coord(w) 
13117      ih = convert_to_FL_Coord(h) 
13118      slabel = convert_to_string(label) 
13119      keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 
13120                     iw, ih, slabel) 
13121      retval = _fl_create_input(iinputtype, ix, iy, iw, ih, slabel) 
13122      return retval 
13123   
13124   
13125 -def fl_add_input(inputtype, x, y, w, h, label): 
13126      """ fl_add_input(inputtype, x, y, w, h, label) -> pObject 
13127      """ 
13128   
13129      _fl_add_input = cfuncproto( 
13130              load_so_libforms(), "fl_add_input", 
13131              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13132              FL_Coord, STRING], 
13133              """FL_OBJECT * fl_add_input(int type, FL_Coord x, FL_Coord y, 
13134                 FL_Coord w, FL_Coord h, const char * label) 
13135              """) 
13136      check_admitted_listvalues(inputtype, INPUTTYPE_list) 
13137      iinputtype = convert_to_int(inputtype) 
13138      ix = convert_to_FL_Coord(x) 
13139      iy = convert_to_FL_Coord(y) 
13140      iw = convert_to_FL_Coord(w) 
13141      ih = convert_to_FL_Coord(h) 
13142      slabel = convert_to_string(label) 
13143      keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 
13144                     iw, ih, slabel) 
13145      retval = _fl_add_input(iinputtype, ix, iy, iw, ih, slabel) 
13146      return retval 
13147   
13148   
13149 -def fl_set_input(pObject, inputstr): 
13150      """ fl_set_input(pObject, inputstr) 
13151      """ 
13152   
13153      _fl_set_input = cfuncproto( 
13154              load_so_libforms(), "fl_set_input", 
13155              None, [cty.POINTER(FL_OBJECT), STRING], 
13156              """void fl_set_input(FL_OBJECT * ob, const char * str) 
13157              """) 
13158      sinputstr = convert_to_string(inputstr) 
13159      keep_elem_refs(pObject, inputstr, sinputstr) 
13160      _fl_set_input(pObject, sinputstr) 
13161   
13162   
13163 -def fl_set_input_return(pObject, value): 
13164      """ fl_set_input_return(pObject, value) 
13165      """ 
13166   
13167      _fl_set_input_return = cfuncproto( 
13168              load_so_libforms(), "fl_set_input_return", 
13169              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13170              """void fl_set_input_return(FL_OBJECT * ob, int value) 
13171              """) 
13172      ivalue = convert_to_int(value) 
13173      keep_elem_refs(pObject, value, ivalue) 
13174      _fl_set_input_return(pObject, ivalue) 
13175   
13176   
13177 -def fl_set_input_color(pObject, textcolr, curscolr): 
13178      """ fl_set_input_color(pObject, textcolr, curscolr) 
13179      """ 
13180   
13181      _fl_set_input_color = cfuncproto( 
13182              load_so_libforms(), "fl_set_input_color", 
13183              None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], 
13184              """void fl_set_input_color(FL_OBJECT * ob, FL_COLOR textcol, 
13185                 FL_COLOR curscol) 
13186              """) 
13187      ultextcolr = convert_to_FL_COLOR(textcolr) 
13188      ulcurscolr = convert_to_FL_COLOR(curscolr) 
13189      keep_elem_refs(pObject, textcolr, curscolr, ultextcolr, ulcurscolr) 
13190      _fl_set_input_color(pObject, ultextcolr, ulcurscolr) 
13191   
13192   
13193  #def fl_get_input_color(pObject, textcolr, curscolr)       *API change* 
13194 -def fl_get_input_color(pObject): 
13195      """ fl_get_input_color(pObject) -> textcolr, curscolr 
13196      """ 
13197   
13198      _fl_get_input_color = cfuncproto( 
13199              load_so_libforms(), "fl_get_input_color", 
13200              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), 
13201              cty.POINTER(FL_COLOR)], 
13202              """void fl_get_input_color(FL_OBJECT * ob, FL_COLOR * textcol, 
13203                 FL_COLOR * curscol) 
13204              """) 
13205      textcolr, ptextcolr = make_ulong_and_pointer() 
13206      curscolr, pcurscolr = make_ulong_and_pointer() 
13207      keep_elem_refs(pObject, textcolr, curscolr) 
13208      _fl_get_input_color(pObject, ptextcolr, pcurscolr) 
13209      return textcolr, curscolr 
13210   
13211   
13212 -def fl_set_input_scroll(pObject, yes): 
13213      """ fl_set_input_scroll(pObject, yes) 
13214      """ 
13215   
13216      _fl_set_input_scroll = cfuncproto( 
13217              load_so_libforms(), "fl_set_input_scroll", 
13218              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13219              """void fl_set_input_scroll(FL_OBJECT * ob, int yes) 
13220              """) 
13221      iyes = convert_to_int(yes) 
13222      keep_elem_refs(pObject, yes, iyes) 
13223      _fl_set_input_scroll(pObject, iyes) 
13224   
13225   
13226 -def fl_set_input_cursorpos(pObject, xpos, ypos): 
13227      """ fl_set_input_cursorpos(pObject, xpos, ypos) 
13228      """ 
13229   
13230      _fl_set_input_cursorpos = cfuncproto( 
13231              load_so_libforms(), "fl_set_input_cursorpos", 
13232              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13233              """void fl_set_input_cursorpos(FL_OBJECT * ob, int xpos, int ypos) 
13234              """) 
13235      ixpos = convert_to_int(xpos) 
13236      iypos = convert_to_int(ypos) 
13237      keep_elem_refs(pObject, xpos, ypos, ixpos, iypos) 
13238      _fl_set_input_cursorpos(pObject, ixpos, iypos) 
13239   
13240   
13241 -def fl_set_input_selected(pObject, yes): 
13242      """ fl_set_input_selected(pObject, yes) 
13243      """ 
13244   
13245      _fl_set_input_selected = cfuncproto( 
13246              load_so_libforms(), "fl_set_input_selected", 
13247              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13248              """void fl_set_input_selected(FL_OBJECT * ob, int yes) 
13249              """) 
13250      iyes = convert_to_int(yes) 
13251      keep_elem_refs(pObject, yes, iyes) 
13252      _fl_set_input_selected(pObject, iyes) 
13253   
13254   
13255 -def fl_set_input_selected_range(pObject, begin, end): 
13256      """ fl_set_input_selected_range(pObject, begin, end) 
13257      """ 
13258   
13259      _fl_set_input_selected_range = cfuncproto( 
13260              load_so_libforms(), "fl_set_input_selected_range", 
13261              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13262              """void fl_set_input_selected_range(FL_OBJECT * ob, 
13263                 int begin, int end) 
13264              """) 
13265      ibegin = convert_to_int(begin) 
13266      iend = convert_to_int(end) 
13267      keep_elem_refs(pObject, begin, end, ibegin, iend) 
13268      _fl_set_input_selected_range(pObject, ibegin, iend) 
13269   
13270   
13271  #def fl_get_input_selected_range(pObject, begin, end)       *API change* 
13272 -def fl_get_input_selected_range(pObject): 
13273      """ fl_get_input_selected_range(pObject) -> string, begin, end 
13274      """ 
13275   
13276      _fl_get_input_selected_range = cfuncproto( 
13277              load_so_libforms(), "fl_get_input_selected_range", 
13278              STRING, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13279              cty.POINTER(cty.c_int)], 
13280              """const char * fl_get_input_selected_range(FL_OBJECT * ob, 
13281                 int * begin, int * end) 
13282              """) 
13283      begin, pbegin = make_int_and_pointer() 
13284      end, pend = make_int_and_pointer() 
13285      keep_elem_refs(pObject, begin, end, pbegin, pend) 
13286      retval = _fl_get_input_selected_range(pObject, pbegin, pend) 
13287      return retval, begin, end 
13288   
13289   
13290 -def fl_set_input_maxchars(pObject, maxchars): 
13291      """ fl_set_input_maxchars(pObject, maxchars) 
13292      """ 
13293   
13294      _fl_set_input_maxchars = cfuncproto( 
13295              load_so_libforms(), "fl_set_input_maxchars", 
13296              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13297              """void fl_set_input_maxchars(FL_OBJECT * ob, int maxchars) 
13298              """) 
13299      imaxchars = convert_to_int(maxchars) 
13300      keep_elem_refs(pObject, maxchars, imaxchars) 
13301      _fl_set_input_maxchars(pObject, imaxchars) 
13302   
13303   
13304 -def fl_set_input_format(pObject, fmt, sep): 
13305      """ fl_set_input_format(pObject, fmt, sep) 
13306      """ 
13307   
13308      _fl_set_input_format = cfuncproto( 
13309              load_so_libforms(), "fl_set_input_format", 
13310              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13311              """void fl_set_input_format(FL_OBJECT * ob, int fmt, int sep) 
13312              """) 
13313      ifmt = convert_to_int(fmt) 
13314      isep = convert_to_int(sep) 
13315      keep_elem_refs(pObject, fmt, sep, ifmt, isep) 
13316      _fl_set_input_format(pObject, ifmt, isep) 
13317   
13318   
13319 -def fl_set_input_hscrollbar(pObject, pref): 
13320      """ fl_set_input_hscrollbar(pObject, pref) 
13321      """ 
13322   
13323      _fl_set_input_hscrollbar = cfuncproto( 
13324              load_so_libforms(), "fl_set_input_hscrollbar", 
13325              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13326              """void fl_set_input_hscrollbar(FL_OBJECT * ob, int pref) 
13327              """) 
13328      ipref = convert_to_int(pref) 
13329      keep_elem_refs(pObject, pref, ipref) 
13330      _fl_set_input_hscrollbar(pObject, ipref) 
13331   
13332   
13333 -def fl_set_input_vscrollbar(pObject, pref): 
13334      """ fl_set_input_vscrollbar(pObject, pref) 
13335      """ 
13336   
13337      _fl_set_input_vscrollbar = cfuncproto( 
13338              load_so_libforms(), "fl_set_input_vscrollbar", 
13339              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13340              """void fl_set_input_vscrollbar(FL_OBJECT * ob, int pref) 
13341              """) 
13342      ipref = convert_to_int(pref) 
13343      keep_elem_refs(pObject, pref, ipref) 
13344      _fl_set_input_vscrollbar(pObject, ipref) 
13345   
13346   
13347 -def fl_set_input_topline(pObject, top): 
13348      """ fl_set_input_topline(pObject, top) 
13349      """ 
13350   
13351      _fl_set_input_topline = cfuncproto( 
13352              load_so_libforms(), "fl_set_input_topline", 
13353              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13354              """void fl_set_input_topline(FL_OBJECT * ob, int top) 
13355              """) 
13356      itop = convert_to_int(top) 
13357      keep_elem_refs(pObject, top, itop) 
13358      _fl_set_input_topline(pObject, itop) 
13359   
13360   
13361 -def fl_set_input_scrollbarsize(pObject, hh, vw): 
13362      """ fl_set_input_scrollbarsize(pObject, hh, vw) 
13363      """ 
13364   
13365      _fl_set_input_scrollbarsize = cfuncproto( 
13366              load_so_libforms(), "fl_set_input_scrollbarsize", 
13367              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13368              """void fl_set_input_scrollbarsize(FL_OBJECT * ob, int hh, int vw) 
13369              """) 
13370      ihh = convert_to_int(hh) 
13371      ivw = convert_to_int(vw) 
13372      keep_elem_refs(pObject, hh, vw, ihh, ivw) 
13373      _fl_set_input_scrollbarsize(pObject, ihh, ivw) 
13374   
13375   
13376  #def fl_get_input_scrollbarsize(pObject, hh, vw)       *API change* 
13377 -def fl_get_input_scrollbarsize(pObject): 
13378      """ fl_get_input_scrollbarsize(pObject) -> hh, vw 
13379      """ 
13380   
13381      _fl_get_input_scrollbarsize = cfuncproto( 
13382              load_so_libforms(), "fl_get_input_scrollbarsize", 
13383              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13384              cty.POINTER(cty.c_int)], 
13385              """void fl_get_input_scrollbarsize(FL_OBJECT * ob, 
13386                 int * hh, int * vw) 
13387              """) 
13388      hh, phh = make_int_and_pointer() 
13389      vw, pvw = make_int_and_pointer() 
13390      keep_elem_refs(pObject, hh, vw) 
13391      _fl_get_input_scrollbarsize(pObject, phh, pvw) 
13392      return hh, vw 
13393   
13394   
13395 -def fl_set_input_xoffset(pObject, xoff): 
13396      """ fl_set_input_xoffset(pObject, xoff) 
13397      """ 
13398   
13399      _fl_set_input_xoffset = cfuncproto( 
13400              load_so_libforms(), "fl_set_input_xoffset", 
13401              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13402              """void fl_set_input_xoffset(FL_OBJECT * ob, int xoff) 
13403              """) 
13404      ixoff = convert_to_int(xoff) 
13405      keep_elem_refs(pObject, xoff, ixoff) 
13406      _fl_set_input_xoffset(pObject, ixoff) 
13407   
13408   
13409 -def fl_get_input_xoffset(pObject): 
13410      """ fl_get_input_xoffset(pObject) -> num. 
13411      """ 
13412   
13413      _fl_get_input_xoffset = cfuncproto( 
13414              load_so_libforms(), "fl_get_input_xoffset", 
13415              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13416              """int fl_get_input_xoffset(FL_OBJECT * ob) 
13417              """) 
13418      keep_elem_refs(pObject) 
13419      retval = _fl_get_input_xoffset(pObject) 
13420      return retval 
13421   
13422   
13423 -def fl_set_input_fieldchar(pObject, fldchar): 
13424      """ fl_set_input_fieldchar(pObject, fldchar) -> num. 
13425      """ 
13426   
13427      _fl_set_input_fieldchar = cfuncproto( 
13428              load_so_libforms(), "fl_set_input_fieldchar", 
13429              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
13430              """int fl_set_input_fieldchar(FL_OBJECT * ob, int fchar) 
13431              """) 
13432      ifldchar = convert_to_int(fldchar) 
13433      keep_elem_refs(pObject, fldchar, ifldchar) 
13434      retval = _fl_set_input_fieldchar(pObject, ifldchar) 
13435      return retval 
13436   
13437   
13438 -def fl_get_input_topline(pObject): 
13439      """ fl_get_input_topline(pObject) -> num. 
13440      """ 
13441   
13442      _fl_get_input_topline = cfuncproto( 
13443              load_so_libforms(), "fl_get_input_topline", 
13444              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13445              """int fl_get_input_topline(FL_OBJECT * ob) 
13446              """) 
13447      keep_elem_refs(pObject) 
13448      retval = _fl_get_input_topline(pObject) 
13449      return retval 
13450   
13451   
13452 -def fl_get_input_screenlines(pObject): 
13453      """ fl_get_input_screenlines(pObject) -> num. 
13454      """ 
13455   
13456      _fl_get_input_screenlines = cfuncproto( 
13457              load_so_libforms(), "fl_get_input_screenlines", 
13458              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13459              """int fl_get_input_screenlines(FL_OBJECT * ob) 
13460              """) 
13461      keep_elem_refs(pObject) 
13462      retval = _fl_get_input_screenlines(pObject) 
13463      return retval 
13464   
13465   
13466  #def fl_get_input_cursorpos(pObject, x, y)       *API change* 
13467 -def fl_get_input_cursorpos(pObject): 
13468      """ fl_get_input_cursorpos(pObject) -> num., x, y 
13469      """ 
13470   
13471      _fl_get_input_cursorpos = cfuncproto( 
13472              load_so_libforms(), "fl_get_input_cursorpos", 
13473              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13474              cty.POINTER(cty.c_int)], 
13475              """int fl_get_input_cursorpos(FL_OBJECT * ob, int * x, int * y) 
13476              """) 
13477      x, px = make_int_and_pointer() 
13478      y, py = make_int_and_pointer() 
13479      keep_elem_refs(pObject, x, y) 
13480      retval = _fl_get_input_cursorpos(pObject, px, py) 
13481      return retval, x, y 
13482   
13483   
13484 -def fl_set_input_cursor_visible(pObject, visible): 
13485      """ fl_set_input_cursor_visible(pObject, visible) 
13486      """ 
13487   
13488      _fl_set_input_cursor_visible = cfuncproto( 
13489              load_so_libforms(), "fl_set_input_cursor_visible", 
13490              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13491              """void fl_set_input_cursor_visible(FL_OBJECT * ob, int visible) 
13492              """) 
13493      ivisible = convert_to_int(visible) 
13494      keep_elem_refs(pObject, visible, ivisible) 
13495      _fl_set_input_cursor_visible(pObject, ivisible) 
13496   
13497   
13498 -def fl_get_input_numberoflines(pObject): 
13499      """ fl_get_input_numberoflines(pObject) -> lines num. 
13500      """ 
13501   
13502      _fl_get_input_numberoflines = cfuncproto( 
13503              load_so_libforms(), "fl_get_input_numberoflines", 
13504              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13505              """int fl_get_input_numberoflines(FL_OBJECT * ob) 
13506              """) 
13507      keep_elem_refs(pObject) 
13508      retval = _fl_get_input_numberoflines(pObject) 
13509      return retval 
13510   
13511   
13512  #def fl_get_input_format(pObject, fmt, sep)       *API change* 
13513 -def fl_get_input_format(pObject): 
13514      """ fl_get_input_format(pObject) -> fmt, sep 
13515      """ 
13516   
13517      _fl_get_input_format = cfuncproto( 
13518              load_so_libforms(), "fl_get_input_format", 
13519              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
13520              cty.POINTER(cty.c_int)], 
13521              """void fl_get_input_format(FL_OBJECT * ob, int * fmt, int * sep) 
13522              """) 
13523      fmt, pfmt = make_int_and_pointer() 
13524      sep, psep = make_int_and_pointer() 
13525      keep_elem_refs(pObject, fmt, sep, pfmt, psep) 
13526      _fl_get_input_format(pObject, pfmt, psep) 
13527      return fmt, sep 
13528   
13529   
13530 -def fl_get_input(pObject): 
13531      """ fl_get_input(pObject) -> input string 
13532      """ 
13533   
13534      _fl_get_input = cfuncproto( 
13535              load_so_libforms(), "fl_get_input", 
13536              STRING, [cty.POINTER(FL_OBJECT)], 
13537              """const char * fl_get_input(FL_OBJECT * ob) 
13538              """) 
13539      keep_elem_refs(pObject) 
13540      retval = _fl_get_input(pObject) 
13541      return retval 
13542   
13543   
13544  FL_INPUTVALIDATOR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), STRING, 
13545                                    STRING, cty.c_int) 
13546   
13547 -def fl_set_input_filter(pObject, py_InputValidator): 
13548      """ 
13549          fl_set_input_filter(pObject, py_InputValidator) -> input_filter func. 
13550      """ 
13551   
13552      _fl_set_input_filter = cfuncproto( 
13553              load_so_libforms(), "fl_set_input_filter", 
13554              FL_INPUTVALIDATOR, [cty.POINTER(FL_OBJECT), FL_INPUTVALIDATOR], 
13555              """FL_INPUTVALIDATOR fl_set_input_filter(FL_OBJECT * ob, 
13556                 FL_INPUTVALIDATOR validate) 
13557              """) 
13558      c_InputValidator = FL_INPUTVALIDATOR(py_InputValidator) 
13559      keep_cfunc_refs(c_InputValidator, py_InputValidator) 
13560      keep_elem_refs(pObject) 
13561      retval = _fl_set_input_filter(pObject, c_InputValidator) 
13562      return retval 
13563   
13564   
13565 -def fl_validate_input(pObject): 
13566      """ fl_validate_input(pObject) -> num. 
13567      """ 
13568   
13569      _fl_validate_input = cfuncproto( 
13570              load_so_libforms(), "fl_validate_input", 
13571              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13572              """int fl_validate_input(FL_OBJECT * obj) 
13573              """) 
13574      keep_elem_refs(pObject) 
13575      retval = _fl_validate_input(pObject) 
13576      return retval 
13577   
13578   
13579  fl_set_input_shortcut = fl_set_object_shortcut 
13580   
13581   
13582  # edit keys 
13583   
13584 -def fl_set_input_editkeymap(pEditKeymap): 
13585      """ fl_set_input_editkeymap(pEditKeymap) 
13586      """ 
13587   
13588      _fl_set_input_editkeymap = cfuncproto( 
13589              load_so_libforms(), "fl_set_input_editkeymap", 
13590              None, [cty.POINTER(FL_EditKeymap)], 
13591              """void fl_set_input_editkeymap(const char * keymap) 
13592              """) 
13593      keep_elem_refs(pEditKeymap) 
13594      _fl_set_input_editkeymap(pEditKeymap) 
13595   
13596   
13597   
13598  ##################### 
13599  # forms.h (menu.h) 
13600  # Object Class: Menu 
13601  ##################### 
13602   
13603  # Routines 
13604   
13605 -def fl_create_menu(menutype, x, y, w, h, label): 
13606      """ fl_create_menu(menutype, x, y, w, h, label) -> pObject 
13607      """ 
13608   
13609      _fl_create_menu = cfuncproto( 
13610              load_so_libforms(), "fl_create_menu", 
13611              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13612              FL_Coord, STRING], 
13613              """FL_OBJECT * fl_create_menu(int type, FL_Coord x, FL_Coord y, 
13614                 FL_Coord w, FL_Coord h, const char * label) 
13615              """) 
13616      check_admitted_listvalues(menutype, MENUTYPE_list) 
13617      imenutype = convert_to_int(menutype) 
13618      ix = convert_to_FL_Coord(x) 
13619      iy = convert_to_FL_Coord(y) 
13620      iw = convert_to_FL_Coord(w) 
13621      ih = convert_to_FL_Coord(h) 
13622      slabel = convert_to_string(label) 
13623      keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 
13624                     iw, ih, slabel) 
13625      retval = _fl_create_menu(imenutype, ix, iy, iw, ih, slabel) 
13626      return retval 
13627   
13628   
13629 -def fl_add_menu(menutype, x, y, w, h, label): 
13630      """ fl_add_menu(menutype, x, y, w, h, label) -> pObject 
13631      """ 
13632   
13633      _fl_add_menu = cfuncproto( 
13634              load_so_libforms(), "fl_add_menu", 
13635              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13636              FL_Coord, STRING], 
13637              """FL_OBJECT * fl_add_menu(int type, FL_Coord x, FL_Coord y, 
13638                 FL_Coord w, FL_Coord h, const char * label)    DEPRECATED 
13639              """) 
13640      check_admitted_listvalues(menutype, MENUTYPE_list) 
13641      imenutype = convert_to_int(menutype) 
13642      ix = convert_to_FL_Coord(x) 
13643      iy = convert_to_FL_Coord(y) 
13644      iw = convert_to_FL_Coord(w) 
13645      ih = convert_to_FL_Coord(h) 
13646      slabel = convert_to_string(label) 
13647      keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 
13648                     iw, ih, slabel) 
13649      retval = _fl_add_menu(imenutype, ix, iy, iw, ih, slabel) 
13650      return retval 
13651   
13652   
13653 -def fl_clear_menu(pObject): 
13654      """ fl_clear_menu(pObject) 
13655      """ 
13656   
13657      _fl_clear_menu = cfuncproto( 
13658              load_so_libforms(), "fl_clear_menu", 
13659              None, [cty.POINTER(FL_OBJECT)], 
13660              """void fl_clear_menu(FL_OBJECT * ob)    DEPRECATED 
13661              """) 
13662      keep_elem_refs(pObject) 
13663      _fl_clear_menu(pObject) 
13664   
13665   
13666 -def fl_set_menu(pObject, menustr): 
13667      """ 
13668          fl_set_menu(pObject, menustr) 
13669   
13670          Sets the menu to a particular menu string. 
13671   
13672          @param pObject : pointer to menu object 
13673          @param menustr : text string of menu 
13674      """ 
13675   
13676      _fl_set_menu = cfuncproto( 
13677              load_so_libforms(), "fl_set_menu", 
13678              None, [cty.POINTER(FL_OBJECT), STRING], 
13679              """void fl_set_menu(FL_OBJECT * ob, const char * menustr)    DEPRECATED 
13680              """) 
13681      smenustr = convert_to_string(menustr) 
13682      keep_elem_refs(pObject, menustr, smenustr) 
13683      _fl_set_menu(pObject, smenustr) 
13684   
13685   
13686 -def fl_addto_menu(pObject, menustr): 
13687      """ fl_addto_menu(pObject, menustr) -> num. 
13688      """ 
13689   
13690      _fl_addto_menu = cfuncproto( 
13691              load_so_libforms(), "fl_addto_menu", 
13692              cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 
13693              """int fl_addto_menu(FL_OBJECT * ob, const char * menustr)    DEPRECATED 
13694              """) 
13695      smenustr = convert_to_string(menustr) 
13696      keep_elem_refs(pObject, menustr, smenustr) 
13697      retval = _fl_addto_menu(pObject, smenustr) 
13698      return retval 
13699   
13700   
13701 -def fl_replace_menu_item(pObject, numb, itemstr): 
13702      """ fl_replace_menu_item(pObject, numb, itemstr) 
13703      """ 
13704   
13705      _fl_replace_menu_item = cfuncproto( 
13706              load_so_libforms(), "fl_replace_menu_item", 
13707              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
13708              """void fl_replace_menu_item(FL_OBJECT * ob, int numb, 
13709                 const char * str)    DEPRECATED 
13710              """) 
13711      inumb = convert_to_int(numb) 
13712      sitemstr = convert_to_string(itemstr) 
13713      keep_elem_refs(pObject, numb, itemstr, inumb, sitemstr) 
13714      _fl_replace_menu_item(pObject, inumb, sitemstr) 
13715   
13716   
13717 -def fl_delete_menu_item(pObject, numb): 
13718      """ fl_delete_menu_item(pObject, numb) 
13719      """ 
13720   
13721      _fl_delete_menu_item = cfuncproto( 
13722              load_so_libforms(), "fl_delete_menu_item", 
13723              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13724              """void fl_delete_menu_item(FL_OBJECT * ob, int numb)    DEPRECATED 
13725              """) 
13726      inumb = convert_to_int(numb) 
13727      keep_elem_refs(pObject, numb, inumb) 
13728      _fl_delete_menu_item(pObject, inumb) 
13729   
13730   
13731  #already defined in xfdata 
13732  FL_PUP_CB = cty.CFUNCTYPE(cty.c_int, cty.c_int) 
13733   
13734 -def fl_set_menu_item_callback(pObject, numb, py_PupCb): 
13735      """ fl_set_menu_item_callback(pObject, numb, py_PupCb) -> callback 
13736      """ 
13737   
13738      _fl_set_menu_item_callback = cfuncproto( 
13739              load_so_libforms(), "fl_set_menu_item_callback", 
13740              FL_PUP_CB, [cty.POINTER(FL_OBJECT), cty.c_int, FL_PUP_CB], 
13741              """FL_PUP_CB fl_set_menu_item_callback(FL_OBJECT * ob, int numb, 
13742                 FL_PUP_CB cb) 
13743              """) 
13744      inumb = convert_to_int(numb) 
13745      c_PupCb = FL_PUP_CB(py_PupCb) 
13746      keep_cfunc_refs(c_PupCb, py_PupCb) 
13747      keep_elem_refs(pObject, numb, inumb) 
13748      retval = _fl_set_menu_item_callback(pObject, inumb, c_PupCb) 
13749      return retval 
13750   
13751   
13752 -def fl_set_menu_item_shortcut(pObject, itemnum, textsc): 
13753      """ 
13754          fl_set_menu_item_shortcut(pObject, itemnum, textsc) 
13755   
13756          Sets the shortcut of a menu item. 
13757   
13758          @param pObject : pointer to menu object 
13759          @param itemnum : item number to be operated on 
13760          @param textsc : text of shortcut to be set 
13761      """ 
13762   
13763      _fl_set_menu_item_shortcut = cfuncproto( 
13764              load_so_libforms(), "fl_set_menu_item_shortcut", 
13765              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
13766              """void fl_set_menu_item_shortcut(FL_OBJECT * ob, int numb, 
13767                 const char * str)   DEPRECATED 
13768              """) 
13769      iitemnum = convert_to_int(itemnum) 
13770      stextsc = convert_to_string(textsc) 
13771      keep_elem_refs(pObject, itemnum, stextsc, iitemnum, stextsc) 
13772      _fl_set_menu_item_shortcut(pObject, iitemnum, stextsc) 
13773   
13774   
13775 -def fl_set_menu_item_mode(pObject, itemnum, mode): 
13776      """ 
13777          fl_set_menu_item_mode(pObject, itemnum, mode) 
13778   
13779          Sets the mode of a menu item. 
13780   
13781          @param pObject : pointer to menu object 
13782          @param itemnum : id of an item to be operated on 
13783          @param mode : mode to be set 
13784      """ 
13785   
13786      _fl_set_menu_item_mode = cfuncproto( 
13787              load_so_libforms(), "fl_set_menu_item_mode", 
13788              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 
13789              """void fl_set_menu_item_mode(FL_OBJECT * ob, int numb, 
13790                 unsigned int mode)   DEPRECATED 
13791              """) 
13792      iitemnum = convert_to_int(itemnum) 
13793      uimode = convert_to_uint(mode) 
13794      keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 
13795      _fl_set_menu_item_mode(pObject, iitemnum, uimode) 
13796   
13797   
13798 -def fl_show_menu_symbol(pObject, showflag): 
13799      """ 
13800          fl_show_menu_symbol(pObject, showflag) 
13801   
13802          Makes the menu symbol visible or not. 
13803   
13804          @param pObject : pointer to menu object 
13805          @param showflag : flag to show menu or not (1|0) 
13806      """ 
13807   
13808      _fl_show_menu_symbol = cfuncproto( 
13809              load_so_libforms(), "fl_show_menu_symbol", 
13810              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13811              """void fl_show_menu_symbol(FL_OBJECT * ob, int show)   DEPRECATED 
13812              """) 
13813      ishowflag = convert_to_int(showflag) 
13814      keep_elem_refs(pObject, showflag, ishowflag) 
13815      _fl_show_menu_symbol(pObject, ishowflag) 
13816   
13817   
13818 -def fl_set_menu_popup(pObject, pup): 
13819      """ fl_set_menu_popup(pObject, pup) 
13820      """ 
13821   
13822      _fl_set_menu_popup = cfuncproto( 
13823              load_so_libforms(), "fl_set_menu_popup", 
13824              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
13825              """void fl_set_menu_popup(FL_OBJECT * ob, int pup)   DEPRECATED 
13826              """) 
13827      ipup = convert_to_int(pup) 
13828      keep_elem_refs(pObject, pup, ipup) 
13829      _fl_set_menu_popup(pObject, ipup) 
13830   
13831   
13832 -def fl_get_menu_popup(pObject): 
13833      """ fl_get_menu_popup(pObject) -> num. 
13834      """ 
13835   
13836      _fl_get_menu_popup = cfuncproto( 
13837              load_so_libforms(), "fl_get_menu_popup", 
13838              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13839              """int fl_get_menu_popup(FL_OBJECT * ob)   DEPRECATED 
13840              """) 
13841      keep_elem_refs(pObject) 
13842      retval = _fl_get_menu_popup(pObject) 
13843      return retval 
13844   
13845   
13846 -def fl_get_menu(pObject): 
13847      """ fl_get_menu(pObject) -> num. 
13848      """ 
13849   
13850      _fl_get_menu = cfuncproto( 
13851              load_so_libforms(), "fl_get_menu", 
13852              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13853              """int fl_get_menu(FL_OBJECT * ob)    DEPRECATED 
13854              """) 
13855      keep_elem_refs(pObject) 
13856      retval = _fl_get_menu(pObject) 
13857      return retval 
13858   
13859   
13860 -def fl_get_menu_item_text(pObject, numb): 
13861      """ fl_get_menu_item_text(pObject, numb) -> text string 
13862      """ 
13863   
13864      _fl_get_menu_item_text = cfuncproto( 
13865              load_so_libforms(), "fl_get_menu_item_text", 
13866              STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 
13867              """const char * fl_get_menu_item_text(FL_OBJECT * ob, int numb)    DEPRECATED 
13868              """) 
13869      inumb = convert_to_int(numb) 
13870      keep_elem_refs(pObject, numb, inumb) 
13871      retval = _fl_get_menu_item_text(pObject, inumb) 
13872      return retval 
13873   
13874   
13875 -def fl_get_menu_maxitems(pObject): 
13876      """ fl_get_menu_maxitems(pObject) -> items num. 
13877      """ 
13878   
13879      _fl_get_menu_maxitems = cfuncproto( 
13880              load_so_libforms(), "fl_get_menu_maxitems", 
13881              cty.c_int, [cty.POINTER(FL_OBJECT)], 
13882              """int fl_get_menu_maxitems(FL_OBJECT * ob)    DEPRECATED 
13883              """) 
13884      keep_elem_refs(pObject) 
13885      retval = _fl_get_menu_maxitems(pObject) 
13886      return retval 
13887   
13888   
13889 -def fl_get_menu_item_mode(pObject, numb): 
13890      """ fl_get_menu_item_mode(pObject, numb) -> mode num. 
13891      """ 
13892   
13893      _fl_get_menu_item_mode = cfuncproto( 
13894              load_so_libforms(), "fl_get_menu_item_mode", 
13895              cty.c_uint, [cty.POINTER(FL_OBJECT), cty.c_int], 
13896              """unsigned int fl_get_menu_item_mode(FL_OBJECT * ob, int numb)   DEPRECATED 
13897              """) 
13898      inumb = convert_to_int(numb) 
13899      keep_elem_refs(pObject, numb, inumb) 
13900      retval = _fl_get_menu_item_mode(pObject, inumb) 
13901      return retval 
13902   
13903   
13904 -def fl_get_menu_text(pObject): 
13905      """ fl_get_menu_text(pObject) -> text string 
13906      """ 
13907   
13908      _fl_get_menu_text = cfuncproto( 
13909              load_so_libforms(), "fl_get_menu_text", 
13910              STRING, [cty.POINTER(FL_OBJECT)], 
13911              """const char * fl_get_menu_text(FL_OBJECT * ob)    DEPRECATED 
13912              """) 
13913      keep_elem_refs(pObject) 
13914      retval = _fl_get_menu_text(pObject) 
13915      return retval 
13916   
13917   
13918 -def fl_set_menu_entries(pObject, pPopupEntry): 
13919      """ fl_set_menu_entries(pObject, pPopupEntry) -> num. 
13920      """ 
13921   
13922      _fl_set_menu_entries = cfuncproto( 
13923              load_so_libforms(), "fl_set_menu_entries", 
13924              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 
13925              """int fl_set_menu_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent)    DEPRECATED 
13926              """) 
13927      keep_elem_refs(pObject, pPopupEntry) 
13928      retval = _fl_set_menu_entries(pObject, pPopupEntry) 
13929      return retval 
13930   
13931   
13932 -def fl_set_menu_notitle(pObject, off): 
13933      """ fl_set_menu_notitle(pObject, off) -> num. 
13934      """ 
13935   
13936      _fl_set_menu_notitle = cfuncproto( 
13937              load_so_libforms(), "fl_set_menu_notitle", 
13938              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
13939              """int fl_set_menu_notitle(FL_OBJECT * ob, int off)   DEPRECATED? 
13940              """) 
13941      ioff = convert_to_int(off) 
13942      keep_elem_refs(pObject, off, ioff) 
13943      retval = _fl_set_menu_notitle(pObject, ioff) 
13944      return retval 
13945   
13946   
13947 -def fl_set_menu_item_id(pObject, item, idnum): 
13948      """ fl_set_menu_item_id(pObject, item, idnum) -> num. 
13949      """ 
13950   
13951      _fl_set_menu_item_id = cfuncproto( 
13952              load_so_libforms(), "fl_set_menu_item_id", 
13953              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
13954              """int fl_set_menu_item_id(FL_OBJECT * ob, int item, int id) 
13955              """) 
13956      iitem = convert_to_int(item) 
13957      iidnum = convert_to_int(idnum) 
13958      keep_elem_refs(pObject, item, idnum, iitem, iidnum) 
13959      retval = _fl_set_menu_item_id(pObject, iitem, iidnum) 
13960      return retval 
13961   
13962   
13963   
13964  # Nmenu object types 
13965   
13966 -def fl_create_nmenu(nmenutype, x, y, w, h, label): 
13967      """ 
13968          fl_create_nmenu(nmenutype, x, y, w, h, label) -> pObject 
13969   
13970          Creates a nmenu object. 
13971   
13972          @param nmenutype : type of nmenu 
13973          @param x : horizontal position of nmenu (upper-left corner) 
13974          @param y : vertical position of nmenu (upper-left corner) 
13975          @param w : width of nmenu object in pixel 
13976          @param h : height of nmenu object in pixel 
13977          @param label : text label of nmenu object 
13978      """ 
13979   
13980      _fl_create_nmenu = cfuncproto( 
13981              load_so_libforms(), "fl_create_nmenu", 
13982              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
13983              FL_Coord, STRING], 
13984              """FL_OBJECT * fl_create_nmenu(int p1, FL_Coord p2, FL_Coord p3, 
13985                 FL_Coord p4, FL_Coord p5, const char * p6) 
13986              """) 
13987      check_admitted_listvalues(nmenutype, NMENUTYPE_list) 
13988      inmenutype = convert_to_int(nmenutype) 
13989      ix = convert_to_FL_Coord(x) 
13990      iy = convert_to_FL_Coord(y) 
13991      iw = convert_to_FL_Coord(w) 
13992      ih = convert_to_FL_Coord(h) 
13993      slabel = convert_to_string(label) 
13994      keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 
13995                     iw, ih, slabel) 
13996      retval = _fl_create_nmenu(inmenutype, ix, iy, iw, ih, slabel) 
13997      return retval 
13998   
13999   
14000 -def fl_add_nmenu(nmenutype, x, y, w, h, label): 
14001      """ 
14002          fl_add_nmenu(nmenutype, x, y, w, h, label) -> pObject 
14003   
14004          Adds a nmenu object. 
14005   
14006          @param nmenutype : type of nmenu object 
14007          @param x : horizontal position of nmenu (upper-left corner) 
14008          @param y : vertical position of nmenu (upper-left corner) 
14009          @param w : width of nmenu object in pixel 
14010          @param h : height of nmenu object in pixel 
14011          @param label : text label of nmenu object 
14012      """ 
14013   
14014      _fl_add_nmenu = cfuncproto( 
14015              load_so_libforms(), "fl_add_nmenu", 
14016              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14017              FL_Coord, STRING], 
14018              """FL_OBJECT * fl_add_nmenu(int p1, FL_Coord p2, FL_Coord p3, 
14019                 FL_Coord p4, FL_Coord p5, const char * p6) 
14020              """) 
14021      check_admitted_listvalues(nmenutype, NMENUTYPE_list) 
14022      inmenutype = convert_to_int(nmenutype) 
14023      ix = convert_to_FL_Coord(x) 
14024      iy = convert_to_FL_Coord(y) 
14025      iw = convert_to_FL_Coord(w) 
14026      ih = convert_to_FL_Coord(h) 
14027      slabel = convert_to_string(label) 
14028      keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 
14029                     iw, ih, slabel) 
14030      retval = _fl_add_nmenu(inmenutype, ix, iy, iw, ih, slabel) 
14031      return retval 
14032   
14033   
14034 -def fl_clear_nmenu(pObject): 
14035      """ fl_clear_nmenu(pObject) -> num. 
14036      """ 
14037   
14038      _fl_clear_nmenu = cfuncproto( 
14039              load_so_libforms(), "fl_clear_nmenu", 
14040              cty.c_int, [cty.POINTER(FL_OBJECT)], 
14041              """int fl_clear_nmenu(FL_OBJECT * p1) 
14042              """) 
14043      keep_elem_refs(pObject) 
14044      retval = _fl_clear_nmenu(pObject) 
14045      return retval 
14046   
14047   
14048 -def fl_add_nmenu_items(pObject, itemstr): 
14049      """ fl_add_nmenu_items(pObject, itemstr) -> pPopupEntry 
14050      """ 
14051   
14052      _fl_add_nmenu_items = cfuncproto( 
14053              load_so_libforms(), "fl_add_nmenu_items", 
14054              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14055              """FL_POPUP_ENTRY * fl_add_nmenu_items(FL_OBJECT * p1, 
14056                 const char * p2) 
14057              """) 
14058      sitemstr = convert_to_string(itemstr) 
14059      keep_elem_refs(pObject, itemstr, sitemstr) 
14060      retval = _fl_add_nmenu_items(pObject, sitemstr) 
14061      return retval 
14062   
14063   
14064 -def fl_insert_nmenu_items(pObject, pPopupEntry, itemstr): 
14065      """ fl_insert_nmenu_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14066      """ 
14067   
14068      _fl_insert_nmenu_items = cfuncproto( 
14069              load_so_libforms(), "fl_insert_nmenu_items", 
14070              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14071              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14072              """FL_POPUP_ENTRY * fl_insert_nmenu_items(FL_OBJECT * p1, 
14073                 FL_POPUP_ENTRY * p2, const char * p3) 
14074              """) 
14075      sitemstr = convert_to_string(itemstr) 
14076      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14077      retval = _fl_insert_nmenu_items(pObject, pPopupEntry, sitemstr) 
14078      return retval 
14079   
14080   
14081 -def fl_replace_nmenu_item(pObject, pPopupEntry, itemstr): 
14082      """ fl_replace_nmenu_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14083      """ 
14084   
14085      _fl_replace_nmenu_item = cfuncproto( 
14086              load_so_libforms(), "fl_replace_nmenu_item", 
14087              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14088              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14089              """FL_POPUP_ENTRY * fl_replace_nmenu_item(FL_OBJECT * p1, 
14090                 FL_POPUP_ENTRY * p2, const char * p3) 
14091              """) 
14092      sitemstr = convert_to_string(itemstr) 
14093      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14094      retval = _fl_replace_nmenu_item(pObject, pPopupEntry, sitemstr) 
14095      return retval 
14096   
14097   
14098 -def fl_delete_nmenu_item(pObject, pPopupEntry): 
14099      """ fl_delete_nmenu_item(pObject, pPopupEntry) -> num. 
14100      """ 
14101   
14102      _fl_delete_nmenu_item = cfuncproto( 
14103              load_so_libforms(), "fl_delete_nmenu_item", 
14104              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 
14105              """int fl_delete_nmenu_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 
14106              """) 
14107      keep_elem_refs(pObject, pPopupEntry) 
14108      retval = _fl_delete_nmenu_item(pObject, pPopupEntry) 
14109      return retval 
14110   
14111   
14112 -def fl_set_nmenu_items(pObject, pPopupItem): 
14113      """ fl_set_nmenu_items(pObject, pPopupItem) -> pPopupEntry 
14114      """ 
14115   
14116      _fl_set_nmenu_items = cfuncproto( 
14117              load_so_libforms(), "fl_set_nmenu_items", 
14118              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14119              cty.POINTER(FL_POPUP_ITEM)], 
14120              """FL_POPUP_ENTRY * fl_set_nmenu_items(FL_OBJECT * p1, 
14121                 FL_POPUP_ITEM * p2) 
14122              """) 
14123      keep_elem_refs(pObject, pPopupItem) 
14124      retval = _fl_set_nmenu_items(pObject, pPopupItem) 
14125      return retval 
14126   
14127   
14128 -def fl_get_nmenu_popup(pObject): 
14129      """ fl_get_nmenu_popup(pObject) -> pPopup 
14130      """ 
14131   
14132      _fl_get_nmenu_popup = cfuncproto( 
14133              load_so_libforms(), "fl_get_nmenu_popup", 
14134              cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 
14135              """FL_POPUP * fl_get_nmenu_popup(FL_OBJECT * p1) 
14136              """) 
14137      keep_elem_refs(pObject) 
14138      retval = _fl_get_nmenu_popup(pObject) 
14139      return retval 
14140   
14141   
14142 -def fl_set_nmenu_popup(pObject, pPopup): 
14143      """ fl_set_nmenu_popup(pObject, pPopup) -> num. 
14144      """ 
14145   
14146      _fl_set_nmenu_popup = cfuncproto( 
14147              load_so_libforms(), "fl_set_nmenu_popup", 
14148              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 
14149              """int fl_set_nmenu_popup(FL_OBJECT * p1, FL_POPUP * p2) 
14150              """) 
14151      keep_elem_refs(pObject, pPopup) 
14152      retval = _fl_set_nmenu_popup(pObject, pPopup) 
14153      return retval 
14154   
14155   
14156 -def fl_get_nmenu_item(pObject): 
14157      """ fl_get_nmenu_item(pObject) -> pPopupReturn 
14158      """ 
14159   
14160      _fl_get_nmenu_item = cfuncproto( 
14161              load_so_libforms(), "fl_get_nmenu_item", 
14162              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 
14163              """FL_POPUP_RETURN * fl_get_nmenu_item(FL_OBJECT * p1) 
14164              """) 
14165      keep_elem_refs(pObject) 
14166      retval = _fl_get_nmenu_item(pObject) 
14167      return retval 
14168   
14169   
14170 -def fl_get_nmenu_item_by_value(pObject, value): 
14171      """ fl_get_nmenu_item_by_value(pObject, value) -> pPopupEntry 
14172      """ 
14173   
14174      _fl_get_nmenu_item_by_value = cfuncproto( 
14175              load_so_libforms(), "fl_get_nmenu_item_by_value", 
14176              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 
14177              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_value(FL_OBJECT * p1, 
14178                 long int p2) 
14179              """) 
14180      lvalue = convert_to_long(value) 
14181      keep_elem_refs(pObject, value, lvalue) 
14182      retval = _fl_get_nmenu_item_by_value(pObject, lvalue) 
14183      return retval 
14184   
14185   
14186 -def fl_get_nmenu_item_by_label(pObject, label): 
14187      """ fl_get_nmenu_item_by_label(pObject, label) -> pPopupEntry 
14188      """ 
14189   
14190      _fl_get_nmenu_item_by_label = cfuncproto( 
14191              load_so_libforms(), "fl_get_nmenu_item_by_label", 
14192              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14193              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_label(FL_OBJECT * p1, 
14194                 const char * p2) 
14195              """) 
14196      slabel = convert_to_string(label) 
14197      keep_elem_refs(pObject, label, slabel) 
14198      retval = _fl_get_nmenu_item_by_label(pObject, slabel) 
14199      return retval 
14200   
14201   
14202 -def fl_get_nmenu_item_by_text(pObject, text): 
14203      """ fl_get_nmenu_item_by_text(pObject, text) -> pPopupEntry 
14204      """ 
14205   
14206      _fl_get_nmenu_item_by_text = cfuncproto( 
14207              load_so_libforms(), "fl_get_nmenu_item_by_text", 
14208              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14209              """FL_POPUP_ENTRY * fl_get_nmenu_item_by_text(FL_OBJECT * p1, 
14210                 const char * p2) 
14211              """) 
14212      stext = convert_to_string(text) 
14213      keep_elem_refs(pObject, text, stext) 
14214      retval = _fl_get_nmenu_item_by_text(pObject, stext) 
14215      return retval 
14216   
14217   
14218 -def fl_set_nmenu_policy(pObject, num): 
14219      """ fl_set_nmenu_policy(pObject, num) -> num. 
14220      """ 
14221   
14222      _fl_set_nmenu_policy = cfuncproto( 
14223              load_so_libforms(), "fl_set_nmenu_policy", 
14224              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
14225              """int fl_set_nmenu_policy(FL_OBJECT * p1, int p2) 
14226              """) 
14227      inum = convert_to_int(num) 
14228      keep_elem_refs(pObject, num, inum) 
14229      retval = _fl_set_nmenu_policy(pObject, inum) 
14230      return retval 
14231   
14232   
14233 -def fl_set_nmenu_hl_text_color(pObject, colr): 
14234      """ fl_set_nmenu_hl_text_color(pObject, colr) -> color 
14235      """ 
14236   
14237      _fl_set_nmenu_hl_text_color = cfuncproto( 
14238              load_so_libforms(), "fl_set_nmenu_hl_text_color", 
14239              FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 
14240              """FL_COLOR fl_set_nmenu_hl_text_color(FL_OBJECT * p1, 
14241                 FL_COLOR p2) 
14242              """) 
14243      ulcolr = convert_to_FL_COLOR(colr) 
14244      keep_elem_refs(pObject, colr, ulcolr) 
14245      retval = _fl_set_nmenu_hl_text_color(pObject, ulcolr) 
14246      return retval 
14247   
14248   
14249   
14250  ######################### 
14251  # forms.h (positioner.h) 
14252  ######################### 
14253   
14254  # Routines 
14255   
14256 -def fl_create_positioner(postype, x, y, w, h, label): 
14257      """ fl_create_positioner(postype, x, y, w, h, label) -> pObject 
14258      """ 
14259   
14260      _fl_create_positioner = cfuncproto( 
14261              load_so_libforms(), "fl_create_positioner", 
14262              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14263              FL_Coord, STRING], 
14264              """FL_OBJECT * fl_create_positioner(int type, FL_Coord x, 
14265                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
14266              """) 
14267      check_admitted_listvalues(postype, POSITIONERTYPE_list) 
14268      ipostype = convert_to_int(postype) 
14269      ix = convert_to_FL_Coord(x) 
14270      iy = convert_to_FL_Coord(y) 
14271      iw = convert_to_FL_Coord(w) 
14272      ih = convert_to_FL_Coord(h) 
14273      slabel = convert_to_string(label) 
14274      keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 
14275                     iw, ih, slabel) 
14276      retval = _fl_create_positioner(ipostype, ix, iy, iw, ih, slabel) 
14277      return retval 
14278   
14279   
14280 -def fl_add_positioner(postype, x, y, w, h, label): 
14281      """ fl_add_positioner(postype, x, y, w, h, label) -> pObject 
14282      """ 
14283   
14284      _fl_add_positioner = cfuncproto( 
14285              load_so_libforms(), "fl_add_positioner", 
14286              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14287              FL_Coord, STRING], 
14288              """FL_OBJECT * fl_add_positioner(int type, FL_Coord x, FL_Coord y, 
14289                 FL_Coord w, FL_Coord h, const char * label) 
14290              """) 
14291      check_admitted_listvalues(postype, POSITIONERTYPE_list) 
14292      ipostype = convert_to_int(postype) 
14293      ix = convert_to_FL_Coord(x) 
14294      iy = convert_to_FL_Coord(y) 
14295      iw = convert_to_FL_Coord(w) 
14296      ih = convert_to_FL_Coord(h) 
14297      slabel = convert_to_string(label) 
14298      keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 
14299                     iw, ih, slabel) 
14300      retval = _fl_add_positioner(ipostype, ix, iy, iw, ih, slabel) 
14301      return retval 
14302   
14303   
14304 -def fl_set_positioner_xvalue(pObject, val): 
14305      """ fl_set_positioner_xvalue(pObject, val) 
14306      """ 
14307   
14308      _fl_set_positioner_xvalue = cfuncproto( 
14309              load_so_libforms(), "fl_set_positioner_xvalue", 
14310              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14311              """void fl_set_positioner_xvalue(FL_OBJECT * ob, double val) 
14312              """) 
14313      fval = convert_to_double(val) 
14314      keep_elem_refs(pObject, val, fval) 
14315      _fl_set_positioner_xvalue(pObject, fval) 
14316   
14317   
14318 -def fl_get_positioner_xvalue(pObject): 
14319      """ fl_get_positioner_xvalue(pObject) -> floatnum 
14320      """ 
14321   
14322      _fl_get_positioner_xvalue = cfuncproto( 
14323              load_so_libforms(), "fl_get_positioner_xvalue", 
14324              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14325              """double fl_get_positioner_xvalue(FL_OBJECT * ob) 
14326              """) 
14327      keep_elem_refs(pObject) 
14328      retval = _fl_get_positioner_xvalue(pObject) 
14329      return retval 
14330   
14331   
14332 -def fl_set_positioner_xbounds(pObject, minbound, maxbound): 
14333      """ fl_set_positioner_xbounds(pObject, minbound, maxbound) 
14334      """ 
14335   
14336      _fl_set_positioner_xbounds = cfuncproto( 
14337              load_so_libforms(), "fl_set_positioner_xbounds", 
14338              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14339              """void fl_set_positioner_xbounds(FL_OBJECT * ob, double min, 
14340                 double max) 
14341              """) 
14342      fminbound = convert_to_double(minbound) 
14343      fmaxbound = convert_to_double(maxbound) 
14344      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14345      _fl_set_positioner_xbounds(pObject, fminbound, fmaxbound) 
14346   
14347   
14348  #def fl_get_positioner_xbounds(pObject, minbound, maxbound)       *API change* 
14349 -def fl_get_positioner_xbounds(pObject): 
14350      """ fl_get_positioner_xbounds(pObject) -> minbound, maxbound 
14351      """ 
14352   
14353      _fl_get_positioner_xbounds = cfuncproto( 
14354              load_so_libforms(), "fl_get_positioner_xbounds", 
14355              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14356              cty.POINTER(cty.c_double)], 
14357              """void fl_get_positioner_xbounds(FL_OBJECT * ob, double * min, 
14358              double * max) 
14359              """) 
14360      minbound, pminbound = make_double_and_pointer() 
14361      maxbound, pmaxbound = make_double_and_pointer() 
14362      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
14363      _fl_get_positioner_xbounds(pObject, pminbound, pmaxbound) 
14364      return minbound, maxbound 
14365   
14366   
14367 -def fl_set_positioner_yvalue(pObject, val): 
14368      """ fl_set_positioner_yvalue(pObject, val) 
14369      """ 
14370   
14371      _fl_set_positioner_yvalue = cfuncproto( 
14372              load_so_libforms(), "fl_set_positioner_yvalue", 
14373              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14374              """void fl_set_positioner_yvalue(FL_OBJECT * ob, double val) 
14375              """) 
14376      fval = convert_to_double(val) 
14377      keep_elem_refs(pObject, val, fval) 
14378      _fl_set_positioner_yvalue(pObject, fval) 
14379   
14380   
14381 -def fl_get_positioner_yvalue(pObject): 
14382      """ fl_get_positioner_yvalue(pObject) -> floatnum 
14383      """ 
14384   
14385      _fl_get_positioner_yvalue = cfuncproto( 
14386              load_so_libforms(), "fl_get_positioner_yvalue", 
14387              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14388              """double fl_get_positioner_yvalue(FL_OBJECT * ob) 
14389              """) 
14390      keep_elem_refs(pObject) 
14391      retval = _fl_get_positioner_yvalue(pObject) 
14392      return retval 
14393   
14394   
14395 -def fl_set_positioner_ybounds(pObject, minbound, maxbound): 
14396      """ fl_set_positioner_ybounds(pObject, minbound, maxbound) 
14397      """ 
14398   
14399      _fl_set_positioner_ybounds = cfuncproto( 
14400              load_so_libforms(), "fl_set_positioner_ybounds", 
14401              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14402              """void fl_set_positioner_ybounds(FL_OBJECT * ob, double min, 
14403                 double max) 
14404              """) 
14405      fminbound = convert_to_double(minbound) 
14406      fmaxbound = convert_to_double(maxbound) 
14407      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14408      _fl_set_positioner_ybounds(pObject, fminbound, fmaxbound) 
14409   
14410   
14411  #def fl_get_positioner_ybounds(pObject, minbound, maxbound)       *API change* 
14412 -def fl_get_positioner_ybounds(pObject): 
14413      """ fl_get_positioner_ybounds(pObject) -> minbound, maxbound 
14414      """ 
14415   
14416      _fl_get_positioner_ybounds = cfuncproto( 
14417              load_so_libforms(), "fl_get_positioner_ybounds", 
14418              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14419              cty.POINTER(cty.c_double)], 
14420              """void fl_get_positioner_ybounds(FL_OBJECT * ob, double * min, 
14421                 double * max) 
14422              """) 
14423      minbound, pminbound = make_double_and_pointer() 
14424      maxbound, pmaxbound = make_double_and_pointer() 
14425      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
14426      _fl_get_positioner_ybounds(pObject, pminbound, pmaxbound) 
14427      return minbound, maxbound 
14428   
14429   
14430 -def fl_set_positioner_xstep(pObject, value): 
14431      """ fl_set_positioner_xstep(pObject, value) 
14432      """ 
14433   
14434      _fl_set_positioner_xstep = cfuncproto( 
14435              load_so_libforms(), "fl_set_positioner_xstep", 
14436              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14437              """void fl_set_positioner_xstep(FL_OBJECT * ob, double value) 
14438              """) 
14439      fvalue = convert_to_double(value) 
14440      keep_elem_refs(pObject, value, fvalue) 
14441      _fl_set_positioner_xstep(pObject, fvalue) 
14442   
14443   
14444 -def fl_set_positioner_ystep(pObject, value): 
14445      """ fl_set_positioner_ystep(pObject, value) 
14446      """ 
14447   
14448      _fl_set_positioner_ystep = cfuncproto( 
14449              load_so_libforms(), "fl_set_positioner_ystep", 
14450              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14451              """void fl_set_positioner_ystep(FL_OBJECT * ob, double value) 
14452              """) 
14453      fvalue = convert_to_double(value) 
14454      keep_elem_refs(pObject, value, fvalue) 
14455      _fl_set_positioner_ystep(pObject, fvalue) 
14456   
14457   
14458 -def fl_set_positioner_return(pObject, value): 
14459      """ fl_set_positioner_return(pObject, value) 
14460      """ 
14461   
14462      _fl_set_positioner_return = cfuncproto( 
14463              load_so_libforms(), "fl_set_positioner_return", 
14464              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
14465              """void fl_set_positioner_return(FL_OBJECT * ob, int value) 
14466              """) 
14467      ivalue = convert_to_int(value) 
14468      keep_elem_refs(pObject, value, ivalue) 
14469      _fl_set_positioner_return(pObject, ivalue) 
14470   
14471   
14472 -def fl_create_scrollbar(scrolltype, x, y, w, h, label): 
14473      """ fl_create_scrollbar(scrolltype, x, y, w, h, label) -> pObject 
14474      """ 
14475   
14476      _fl_create_scrollbar = cfuncproto( 
14477              load_so_libforms(), "fl_create_scrollbar", 
14478              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14479              FL_Coord, STRING], 
14480              """FL_OBJECT * fl_create_scrollbar(int type, FL_Coord x, 
14481                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
14482              """) 
14483      check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 
14484      iscrolltype = convert_to_int(scrolltype) 
14485      ix = convert_to_FL_Coord(x) 
14486      iy = convert_to_FL_Coord(y) 
14487      iw = convert_to_FL_Coord(w) 
14488      ih = convert_to_FL_Coord(h) 
14489      slabel = convert_to_string(label) 
14490      keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 
14491                     iw, ih, slabel) 
14492      retval = _fl_create_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 
14493      return retval 
14494   
14495   
14496 -def fl_add_scrollbar(scrolltype, x, y, w, h, label): 
14497      """ 
14498          fl_add_scrollbar(scrolltype, x, y, w, h, label) -> pObject 
14499   
14500          Adds a scrollbar to a form. 
14501   
14502          @param scrolltype : type of scrollbar 
14503          @param x : horizontal position (upper-left corner) 
14504          @param y : vertical position (upper-left corner) 
14505          @param w : width of the scrollbar 
14506          @param h : height of the scrollbar 
14507          @param label : label text of the scrollbar 
14508      """ 
14509   
14510      _fl_add_scrollbar = cfuncproto( 
14511              load_so_libforms(), "fl_add_scrollbar", 
14512              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14513              FL_Coord, STRING], 
14514              """FL_OBJECT * fl_add_scrollbar(int type, FL_Coord x, FL_Coord y, 
14515                 FL_Coord w, FL_Coord h, const char * label) 
14516              """) 
14517      check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 
14518      iscrolltype = convert_to_int(scrolltype) 
14519      ix = convert_to_FL_Coord(x) 
14520      iy = convert_to_FL_Coord(y) 
14521      iw = convert_to_FL_Coord(w) 
14522      ih = convert_to_FL_Coord(h) 
14523      slabel = convert_to_string(label) 
14524      keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 
14525                     iw, ih, slabel) 
14526      retval = _fl_add_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 
14527      return retval 
14528   
14529   
14530 -def fl_get_scrollbar_value(pObject): 
14531      """ 
14532          fl_get_scrollbar_value(pObject) -> value[float] 
14533   
14534          Returns the value of a scrollbar. 
14535   
14536          @param pObject : pointer to object 
14537      """ 
14538   
14539      _fl_get_scrollbar_value = cfuncproto( 
14540              load_so_libforms(), "fl_get_scrollbar_value", 
14541              cty.c_double, [cty.POINTER(FL_OBJECT)], 
14542              """double fl_get_scrollbar_value(FL_OBJECT * ob) 
14543              """) 
14544      keep_elem_refs(pObject) 
14545      retval = _fl_get_scrollbar_value(pObject) 
14546      return retval 
14547   
14548   
14549 -def fl_set_scrollbar_value(pObject, val): 
14550      """ 
14551          fl_set_scrollbar_value(pObject, val) 
14552   
14553          Sets the value of a scrollbar. 
14554   
14555          @param pObject : pointer to object 
14556          @param val : value of the scrollbar to be set 
14557      """ 
14558   
14559      _fl_set_scrollbar_value = cfuncproto( 
14560              load_so_libforms(), "fl_set_scrollbar_value", 
14561              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14562              """void fl_set_scrollbar_value(FL_OBJECT * ob, double val) 
14563              """) 
14564      fval = convert_to_double(val) 
14565      keep_elem_refs(pObject, val, fval) 
14566      _fl_set_scrollbar_value(pObject, fval) 
14567   
14568   
14569 -def fl_set_scrollbar_size(pObject, val): 
14570      """ fl_set_scrollbar_size(pObject, val) 
14571      """ 
14572   
14573      _fl_set_scrollbar_size = cfuncproto( 
14574              load_so_libforms(), "fl_set_scrollbar_size", 
14575              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14576              """void fl_set_scrollbar_size(FL_OBJECT * ob, double val) 
14577              """) 
14578      fval = convert_to_double(val) 
14579      keep_elem_refs(pObject, val, fval) 
14580      _fl_set_scrollbar_size(pObject, fval) 
14581   
14582   
14583 -def fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval): 
14584      """ 
14585          fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval) 
14586   
14587          Sets the size of the steps of a scrollbar jump. 
14588   
14589          @param pObject : pointer to object 
14590          @param leftbtnval : value to increment if the left mouse button is 
14591             pressed 
14592          @param midlbtnval : value to increment if the middle mouse button is 
14593             pressed 
14594      """ 
14595   
14596      _fl_set_scrollbar_increment = cfuncproto( 
14597              load_so_libforms(), "fl_set_scrollbar_increment", 
14598              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14599              """void fl_set_scrollbar_increment(FL_OBJECT * ob, double l, 
14600                 double r) 
14601              """) 
14602      fleftbtnval = convert_to_double(leftbtnval) 
14603      fmidlbtnval = convert_to_double(midlbtnval) 
14604      keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, \ 
14605                     fmidlbtnval) 
14606      _fl_set_scrollbar_increment(pObject, fleftbtnval, fmidlbtnval) 
14607   
14608   
14609  #def fl_get_scrollbar_increment(pObject, leftbtnval, valmidlbtnval)       *API change* 
14610 -def fl_get_scrollbar_increment(pObject): 
14611      """ 
14612          fl_get_scrollbar_increment(pObject) -> leftbtnval[double], midlbtnval[double] 
14613   
14614          Returns the increment of size of a scrollbar for left and middle mouse 
14615          buttons. 
14616   
14617          @param pObject : pointer to object 
14618      """ 
14619   
14620      _fl_get_scrollbar_increment = cfuncproto( 
14621              load_so_libforms(), "fl_get_scrollbar_increment", 
14622              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14623              cty.POINTER(cty.c_double)], 
14624              """void fl_get_scrollbar_increment(FL_OBJECT * ob, double * a, 
14625                 double * b) 
14626              """) 
14627      leftbtnval, pleftbtnval = make_double_and_pointer() 
14628      midlbtnval, pmidlbtnval = make_double_and_pointer() 
14629      keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 
14630      _fl_get_scrollbar_increment(pObject, pleftbtnval, pmidlbtnval) 
14631      return leftbtnval, midlbtnval 
14632   
14633   
14634 -def fl_set_scrollbar_bounds(pObject, minbound, maxbound): 
14635      """ 
14636          fl_set_scrollbar_bounds(pObject, minbound, maxbound) 
14637   
14638          Sets the bounds/limits of a scrollbar. 
14639   
14640          @param pObject : pointer to object 
14641          @param minbound : minimum bound of scrollbar 
14642          @param maxbound : maximum bound of scrollbar 
14643      """ 
14644   
14645      _fl_set_scrollbar_bounds = cfuncproto( 
14646              load_so_libforms(), "fl_set_scrollbar_bounds", 
14647              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
14648              """void fl_set_scrollbar_bounds(FL_OBJECT * ob, double b1, double b2) 
14649              """) 
14650      fminbound = convert_to_double(minbound) 
14651      fmaxbound = convert_to_double(maxbound) 
14652      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
14653      _fl_set_scrollbar_bounds(pObject, fminbound, fmaxbound) 
14654   
14655   
14656  #def fl_get_scrollbar_bounds(pObject, b1, b2)       *API change* 
14657 -def fl_get_scrollbar_bounds(pObject): 
14658      """ 
14659          fl_get_scrollbar_bounds(pObject) -> minbound, maxbound 
14660   
14661          Returns the bounds/limits of a scrollbar. 
14662   
14663          @param pObject : pointer to scrollbar object 
14664      """ 
14665   
14666      _fl_get_scrollbar_bounds = cfuncproto( 
14667              load_so_libforms(), "fl_get_scrollbar_bounds", 
14668              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
14669              cty.POINTER(cty.c_double)], 
14670              """void fl_get_scrollbar_bounds(FL_OBJECT * ob, double * b1, 
14671                 double * b2) 
14672              """) 
14673      minbound, pminbound = make_double_and_pointer() 
14674      maxbound, pmaxbound = make_double_and_pointer() 
14675      keep_elem_refs(pObject, minbound, pminbound, maxbound, pmaxbound) 
14676      _fl_get_scrollbar_bounds(pObject, pminbound, pmaxbound) 
14677      return minbound, maxbound 
14678   
14679   
14680 -def fl_set_scrollbar_return(pObject, returnnum): 
14681      """ 
14682          fl_set_scrollbar_return(pObject, returnnum) 
14683   
14684          Sets the type of return of a scrollbar. 
14685   
14686          @param pObject : pointer to scrollbar object 
14687          @param returnnum : value of return type 
14688      """ 
14689   
14690      _fl_set_scrollbar_return = cfuncproto( 
14691              load_so_libforms(), "fl_set_scrollbar_return", 
14692              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
14693              """void fl_set_scrollbar_return(FL_OBJECT * ob, int ret) 
14694              """) 
14695      check_admitted_listvalues(returnnum, RETURN_list) 
14696      ireturnnum = convert_to_int(returnnum) 
14697      keep_elem_refs(pObject, returnnum, ireturnnum) 
14698      _fl_set_scrollbar_return(pObject, ireturnnum) 
14699   
14700   
14701 -def fl_set_scrollbar_step(pObject, step): 
14702      """ fl_set_scrollbar_step(pObject, step) 
14703      """ 
14704   
14705      _fl_set_scrollbar_step = cfuncproto( 
14706              load_so_libforms(), "fl_set_scrollbar_step", 
14707              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
14708              """void fl_set_scrollbar_step(FL_OBJECT * ob, double step) 
14709              """) 
14710      fstep = convert_to_double(step) 
14711      keep_elem_refs(pObject, step, fstep) 
14712      _fl_set_scrollbar_step(pObject, fstep) 
14713   
14714   
14715   
14716  ##################### 
14717  # forms.h (select.h) 
14718  ##################### 
14719   
14720  # Select object types 
14721   
14722 -def fl_create_select(selecttype, x, y, w, h, label): 
14723      """ fl_create_select(selecttype, x, y, w, h, label) -> pObject 
14724      """ 
14725   
14726      _fl_create_select = cfuncproto( 
14727              load_so_libforms(), "fl_create_select", 
14728              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14729              FL_Coord, STRING], 
14730              """FL_OBJECT * fl_create_select(int p1, FL_Coord p2, FL_Coord p3, 
14731                 FL_Coord p4, FL_Coord p5, const char * p6) 
14732              """) 
14733      check_admitted_listvalues(selecttype, SELECTTYPE_list) 
14734      iselecttype = convert_to_int(selecttype) 
14735      ix = convert_to_FL_Coord(x) 
14736      iy = convert_to_FL_Coord(y) 
14737      iw = convert_to_FL_Coord(w) 
14738      ih = convert_to_FL_Coord(h) 
14739      slabel = convert_to_string(label) 
14740      keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 
14741                     iw, ih, slabel) 
14742      retval = _fl_create_select(iselecttype, ix, iy, iw, ih, slabel) 
14743      return retval 
14744   
14745   
14746 -def fl_add_select(selecttype, x, y, w, h, label): 
14747      """ fl_add_select(selecttype, x, y, w, h, label) -> pObject 
14748      """ 
14749   
14750      _fl_add_select = cfuncproto( 
14751              load_so_libforms(), "fl_add_select", 
14752              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
14753              FL_Coord, STRING], 
14754              """FL_OBJECT * fl_add_select(int p1, FL_Coord p2, FL_Coord p3, 
14755                 FL_Coord p4, FL_Coord p5, const char * p6) 
14756              """) 
14757      check_admitted_listvalues(selecttype, SELECTTYPE_list) 
14758      iselecttype = convert_to_int(selecttype) 
14759      ix = convert_to_FL_Coord(x) 
14760      iy = convert_to_FL_Coord(y) 
14761      iw = convert_to_FL_Coord(w) 
14762      ih = convert_to_FL_Coord(h) 
14763      slabel = convert_to_string(label) 
14764      keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 
14765                     iw, ih, slabel) 
14766      retval = _fl_add_select(iselecttype, ix, iy, iw, ih, slabel) 
14767      return retval 
14768   
14769   
14770 -def fl_clear_select(pObject): 
14771      """ fl_clear_select(pObject) 
14772   
14773          @param pObject : pointer to select object 
14774      """ 
14775   
14776      _fl_clear_select = cfuncproto( 
14777              load_so_libforms(), "fl_clear_select", 
14778              cty.c_int, [cty.POINTER(FL_OBJECT)], 
14779              """int fl_clear_select(FL_OBJECT * p1) 
14780              """) 
14781      keep_elem_refs(pObject) 
14782      _fl_clear_select(pObject) 
14783   
14784   
14785 -def fl_add_select_items(pObject, itemstr): 
14786      """ fl_add_select_items(pObject, itemstr) -> pPopupEntry 
14787      """ 
14788   
14789      _fl_add_select_items = cfuncproto( 
14790              load_so_libforms(), "fl_add_select_items", 
14791              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14792              """FL_POPUP_ENTRY * fl_add_select_items(FL_OBJECT * p1, 
14793                 const char * p2) 
14794              """) 
14795      sitemstr = convert_to_string(itemstr) 
14796      keep_elem_refs(pObject, itemstr, sitemstr) 
14797      retval = _fl_add_select_items(pObject, sitemstr) 
14798      return retval 
14799   
14800   
14801 -def fl_insert_select_items(pObject, pPopupEntry, itemstr): 
14802      """ fl_insert_select_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14803      """ 
14804   
14805      _fl_insert_select_items = cfuncproto( 
14806              load_so_libforms(), "fl_insert_select_items", 
14807              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14808              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14809              """FL_POPUP_ENTRY * fl_insert_select_items(FL_OBJECT * p1, 
14810                 FL_POPUP_ENTRY * p2, const char * p3) 
14811              """) 
14812      sitemstr = convert_to_string(itemstr) 
14813      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14814      retval = _fl_insert_select_items(pObject, pPopupEntry, sitemstr) 
14815      return retval 
14816   
14817   
14818 -def fl_replace_select_item(pObject, pPopupEntry, itemstr): 
14819      """ fl_replace_select_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 
14820      """ 
14821   
14822      _fl_replace_select_item = cfuncproto( 
14823              load_so_libforms(), "fl_replace_select_item", 
14824              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 
14825              cty.POINTER(FL_POPUP_ENTRY), STRING], 
14826              """FL_POPUP_ENTRY * fl_replace_select_item(FL_OBJECT * p1, 
14827                 FL_POPUP_ENTRY * p2, const char * p3) 
14828              """) 
14829      sitemstr = convert_to_string(itemstr) 
14830      keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 
14831      retval = _fl_replace_select_item(pObject, pPopupEntry, sitemstr) 
14832      return retval 
14833   
14834   
14835 -def fl_delete_select_item(pObject, pPopupEntry): 
14836      """ fl_delete_select_item(pObject, pPopupEntry) -> num. 
14837      """ 
14838   
14839      _fl_delete_select_item = cfuncproto( 
14840              load_so_libforms(), "fl_delete_select_item", 
14841              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 
14842              """int fl_delete_select_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 
14843              """) 
14844      keep_elem_refs(pObject, pPopupEntry) 
14845      retval = _fl_delete_select_item(pObject, pPopupEntry) 
14846      return retval 
14847   
14848   
14849 -def fl_set_select_items(pObject, pPopupItem): 
14850      """ 
14851          fl_set_select_items(pObject, pPopupItem) -> num. 
14852   
14853          Repopulates a select object popup. 
14854   
14855          @param pObject : pointer to select object 
14856          @param pPopupItem : pointer to xfc.FL_POPUP_ITEM structure 
14857      """ 
14858   
14859      _fl_set_select_items = cfuncproto( 
14860              load_so_libforms(), "fl_set_select_items", 
14861              cty.c_long, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ITEM)], 
14862              """long int fl_set_select_items(FL_OBJECT * p1, 
14863                 FL_POPUP_ITEM * p2) 
14864              """) 
14865      #pPopupItem.callback = FL_POPUP_CB() 
14866      keep_elem_refs(pObject, pPopupItem) 
14867      retval = _fl_set_select_items(pObject, pPopupItem) 
14868      return retval 
14869   
14870   
14871 -def fl_get_select_popup(pObject): 
14872      """ fl_get_select_popup(pObject) -> pPopup 
14873      """ 
14874   
14875      _fl_get_select_popup = cfuncproto( 
14876              load_so_libforms(), "fl_get_select_popup", 
14877              cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 
14878              """FL_POPUP * fl_get_select_popup(FL_OBJECT * p1) 
14879              """) 
14880      keep_elem_refs(pObject) 
14881      retval = _fl_get_select_popup(pObject) 
14882      return retval 
14883   
14884   
14885 -def fl_set_select_popup(pObject, pPopup): 
14886      """ fl_set_select_popup(pObject, pPopup) -> num. 
14887      """ 
14888   
14889      _fl_set_select_popup = cfuncproto( 
14890              load_so_libforms(), "fl_set_select_popup", 
14891              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 
14892              """int fl_set_select_popup(FL_OBJECT * p1, FL_POPUP * p2) 
14893              """) 
14894      keep_elem_refs(pObject, pPopup) 
14895      retval = _fl_set_select_popup(pObject, pPopup) 
14896      return retval 
14897   
14898   
14899 -def fl_get_select_item(pObject): 
14900      """ fl_get_select_item(pObject) -> pPopupReturn 
14901      """ 
14902   
14903      _fl_get_select_item = cfuncproto( 
14904              load_so_libforms(), "fl_get_select_item", 
14905              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 
14906              """FL_POPUP_RETURN * fl_get_select_item(FL_OBJECT * p1) 
14907              """) 
14908      keep_elem_refs(pObject) 
14909      retval = _fl_get_select_item(pObject) 
14910      return retval 
14911   
14912   
14913 -def fl_set_select_item(pObject, pPopupEntry): 
14914      """ fl_set_select_item(pObject, pPopupEntry) -> pPopupReturn 
14915      """ 
14916   
14917      _fl_set_select_item = cfuncproto( 
14918              load_so_libforms(), "fl_set_select_item", 
14919              cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT), 
14920              cty.POINTER(FL_POPUP_ENTRY)], 
14921              """FL_POPUP_RETURN * fl_set_select_item(FL_OBJECT * p1, 
14922                 FL_POPUP_ENTRY * p2) 
14923              """) 
14924      keep_elem_refs(pObject, pPopupEntry) 
14925      retval = _fl_set_select_item(pObject, pPopupEntry) 
14926      return retval 
14927   
14928   
14929 -def fl_get_select_item_by_value(pObject, value): 
14930      """ fl_get_select_item_by_value(pObject, value) -> pPopupEntry 
14931      """ 
14932   
14933      _fl_get_select_item_by_value = cfuncproto( 
14934              load_so_libforms(), "fl_get_select_item_by_value", 
14935              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 
14936              """FL_POPUP_ENTRY * fl_get_select_item_by_value(FL_OBJECT * p1, 
14937                 long int p2) 
14938              """) 
14939      lvalue = convert_to_long(value) 
14940      keep_elem_refs(pObject, value, lvalue) 
14941      retval = _fl_get_select_item_by_value(pObject, lvalue) 
14942      return retval 
14943   
14944   
14945 -def fl_get_select_item_by_label(pObject, label): 
14946      """ fl_get_select_item_by_label(pObject, label) -> pPopupEntry 
14947      """ 
14948   
14949      _fl_get_select_item_by_label = cfuncproto( 
14950              load_so_libforms(), "fl_get_select_item_by_label", 
14951              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14952              """FL_POPUP_ENTRY * fl_get_select_item_by_label(FL_OBJECT * p1, 
14953                 const char * p2) 
14954              """) 
14955      slabel = convert_to_string(label) 
14956      keep_elem_refs(pObject, label, slabel) 
14957      retval = _fl_get_select_item_by_label(pObject, slabel) 
14958      return retval 
14959   
14960   
14961 -def fl_get_select_item_by_text(pObject, txtstr): 
14962      """ fl_get_select_item_by_text(pObject, txtstr) -> pPopupEntry 
14963      """ 
14964   
14965      _fl_get_select_item_by_text = cfuncproto( 
14966              load_so_libforms(), "fl_get_select_item_by_text", 
14967              cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 
14968              """FL_POPUP_ENTRY * fl_get_select_item_by_text(FL_OBJECT * p1, 
14969                 const char * p2) 
14970              """) 
14971      stxtstr = convert_to_string(txtstr) 
14972      keep_elem_refs(pObject, txtstr, stxtstr) 
14973      retval = _fl_get_select_item_by_text(pObject, stxtstr) 
14974      return retval 
14975   
14976   
14977 -def fl_get_select_text_color(pObject): 
14978      """ fl_get_select_text_color(pObject) -> color 
14979      """ 
14980   
14981      _fl_get_select_text_color = cfuncproto( 
14982              load_so_libforms(), "fl_get_select_text_color", 
14983              FL_COLOR, [cty.POINTER(FL_OBJECT)], 
14984              """FL_COLOR fl_get_select_text_color(FL_OBJECT * p1) 
14985              """) 
14986      keep_elem_refs(pObject) 
14987      retval = _fl_get_select_text_color(pObject) 
14988      return retval 
14989   
14990   
14991 -def fl_set_select_text_color(pObject, colr): 
14992      """ fl_set_select_text_color(pObject, colr) -> color 
14993      """ 
14994   
14995      _fl_set_select_text_color = cfuncproto( 
14996              load_so_libforms(), "fl_set_select_text_color", 
14997              FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 
14998              """FL_COLOR fl_set_select_text_color(FL_OBJECT * p1, FL_COLOR p2) 
14999              """) 
15000      ulcolr = convert_to_FL_COLOR(colr) 
15001      keep_elem_refs(pObject, colr, ulcolr) 
15002      retval = _fl_set_select_text_color(pObject, ulcolr) 
15003      return retval 
15004   
15005   
15006  #def fl_get_select_text_font(pObject, p2, p3)       *API change* 
15007 -def fl_get_select_text_font(pObject): 
15008      """ fl_get_select_text_font(pObject) -> num, num1, num2 
15009      """ 
15010   
15011      _fl_get_select_text_font = cfuncproto( 
15012              load_so_libforms(), "fl_get_select_text_font", 
15013              cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 
15014              cty.POINTER(cty.c_int)], 
15015              """int fl_get_select_text_font(FL_OBJECT * p1, int * p2, int * p3) 
15016              """) 
15017      num1, pnum1 = make_int_and_pointer() 
15018      num2, pnum2 = make_int_and_pointer() 
15019      keep_elem_refs(pObject, num1, num2, pnum1, pnum2) 
15020      retval = _fl_get_select_text_font(pObject, pnum2, pnum2) 
15021      return retval, num1, num2 
15022   
15023   
15024 -def fl_set_select_text_font(pObject, p2, p3): 
15025      """ fl_set_select_text_font(pObject, p2, p3) -> font num. 
15026      """ 
15027   
15028      _fl_set_select_text_font = cfuncproto( 
15029              load_so_libforms(), "fl_set_select_text_font", 
15030              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
15031              """int fl_set_select_text_font(FL_OBJECT * p1, int p2, int p3) 
15032              """) 
15033      ip2 = convert_to_int(p2) 
15034      ip3 = convert_to_int(p3) 
15035      keep_elem_refs(pObject, p2, p3, ip2, ip3) 
15036      retval = _fl_set_select_text_font(pObject, ip2, ip3) 
15037      return retval 
15038   
15039   
15040 -def fl_get_select_text_align(pObject): 
15041      """ fl_get_select_text_align(pObject) -> num. 
15042      """ 
15043   
15044      _fl_get_select_text_align = cfuncproto( 
15045              load_so_libforms(), "fl_get_select_text_align", 
15046              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15047              """int fl_get_select_text_align(FL_OBJECT * p1) 
15048              """) 
15049      keep_elem_refs(pObject) 
15050      retval = _fl_get_select_text_align(pObject) 
15051      return retval 
15052   
15053   
15054 -def fl_set_select_text_align(pObject, p2): 
15055      """ fl_set_select_text_align(pObject, p2) -> num. 
15056      """ 
15057   
15058      _fl_set_select_text_align = cfuncproto( 
15059              load_so_libforms(), "fl_set_select_text_align", 
15060              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15061              """int fl_set_select_text_align(FL_OBJECT * p1, int p2) 
15062              """) 
15063      ip2 = convert_to_int(p2) 
15064      keep_elem_refs(pObject, p2, ip2) 
15065      retval = _fl_set_select_text_align(pObject, ip2) 
15066      return retval 
15067   
15068   
15069 -def fl_set_select_policy(pObject, num): 
15070      """ fl_set_select_policy(pObject, num) -> num. 
15071      """ 
15072   
15073      _fl_set_select_policy = cfuncproto( 
15074              load_so_libforms(), "fl_set_select_policy", 
15075              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15076              """int fl_set_select_policy(FL_OBJECT * p1, int p2) 
15077              """) 
15078      inum = convert_to_int(num) 
15079      keep_elem_refs(pObject, num, inum) 
15080      retval = _fl_set_select_policy(pObject, inum) 
15081      return retval 
15082   
15083   
15084   
15085  ####################### 
15086  # forms.h (slider.h) 
15087  # Object Class: Slider 
15088  ####################### 
15089   
15090  # Routines 
15091   
15092 -def fl_create_slider(slidertype, x, y, w, h, label): 
15093      """ fl_create_slider(slidertype, x, y, w, h, label) -> pObject 
15094      """ 
15095   
15096      _fl_create_slider = cfuncproto( 
15097              load_so_libforms(), "fl_create_slider", 
15098              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15099              FL_Coord, STRING], 
15100              """FL_OBJECT * fl_create_slider(int type, FL_Coord x, FL_Coord y, 
15101                 FL_Coord w, FL_Coord h, const char * label) 
15102              """) 
15103      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15104      islidertype = convert_to_int(slidertype) 
15105      ix = convert_to_FL_Coord(x) 
15106      iy = convert_to_FL_Coord(y) 
15107      iw = convert_to_FL_Coord(w) 
15108      ih = convert_to_FL_Coord(h) 
15109      slabel = convert_to_string(label) 
15110      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15111                     iw, ih, slabel) 
15112      retval = _fl_create_slider(islidertype, ix, iy, iw, ih, slabel) 
15113      return retval 
15114   
15115   
15116 -def fl_add_slider(slidertype, x, y, w, h, label): 
15117      """ 
15118          fl_add_slider(slidertype, x, y, w, h, label) -> pObject 
15119   
15120          Adds a slider to a form. No value is displayed. 
15121   
15122          @param slidertype : type of the slider 
15123          @param x : horizontal position (upper-left corner) 
15124          @param y : vertical position (upper-left corner) 
15125          @param w : width of the slider 
15126          @param h : height of the slider 
15127          @param label : label of the slider (placed below it by default) 
15128      """ 
15129   
15130      _fl_add_slider = cfuncproto( 
15131              load_so_libforms(), "fl_add_slider", 
15132              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15133              FL_Coord, STRING], 
15134              """FL_OBJECT * fl_add_slider(int type, FL_Coord x, FL_Coord y, 
15135                 FL_Coord w, FL_Coord h, const char * label) 
15136              """) 
15137      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15138      islidertype = convert_to_int(slidertype) 
15139      ix = convert_to_FL_Coord(x) 
15140      iy = convert_to_FL_Coord(y) 
15141      iw = convert_to_FL_Coord(w) 
15142      ih = convert_to_FL_Coord(h) 
15143      slabel = convert_to_string(label) 
15144      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15145                     iw, ih, slabel) 
15146      retval = _fl_add_slider(islidertype, ix, iy, iw, ih, slabel) 
15147      return retval 
15148   
15149   
15150 -def fl_create_valslider(slidertype, x, y, w, h, label): 
15151      """ fl_create_valslider(slidertype, x, y, w, h, label) -> pObject 
15152      """ 
15153   
15154      _fl_create_valslider = cfuncproto( 
15155              load_so_libforms(), "fl_create_valslider", 
15156              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15157              FL_Coord, STRING], 
15158              """FL_OBJECT * fl_create_valslider(int type, FL_Coord x, 
15159                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
15160              """) 
15161      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15162      islidertype = convert_to_int(slidertype) 
15163      ix = convert_to_FL_Coord(x) 
15164      iy = convert_to_FL_Coord(y) 
15165      iw = convert_to_FL_Coord(w) 
15166      ih = convert_to_FL_Coord(h) 
15167      slabel = convert_to_string(label) 
15168      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15169                     iw, ih, slabel) 
15170      retval = _fl_create_valslider(islidertype, ix, iy, iw, ih, slabel) 
15171      return retval 
15172   
15173   
15174 -def fl_add_valslider(slidertype, x, y, w, h, label): 
15175      """ 
15176          fl_add_valslider(slidertype, x, y, w, h, label) -> pObject 
15177   
15178          Adds a slider to a form. Its value is displayed above or to the 
15179          left of the slider. 
15180   
15181          @param slidertype : type of the slider 
15182          @param x : horizontal position (upper-left corner) 
15183          @param y : vertical position (upper-left corner) 
15184          @param w : width of the slider 
15185          @param h : height of the slider 
15186          @param label : label of the slider (placed below it by default) 
15187      """ 
15188   
15189      _fl_add_valslider = cfuncproto( 
15190              load_so_libforms(), "fl_add_valslider", 
15191              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15192              FL_Coord, STRING], 
15193              """FL_OBJECT * fl_add_valslider(int type, FL_Coord x, FL_Coord y, 
15194                 FL_Coord w, FL_Coord h, const char * label) 
15195              """) 
15196      check_admitted_listvalues(slidertype, SLIDERTYPE_list) 
15197      islidertype = convert_to_int(slidertype) 
15198      ix = convert_to_FL_Coord(x) 
15199      iy = convert_to_FL_Coord(y) 
15200      iw = convert_to_FL_Coord(w) 
15201      ih = convert_to_FL_Coord(h) 
15202      slabel = convert_to_string(label) 
15203      keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 
15204                     iw, ih, slabel) 
15205      retval = _fl_add_valslider(islidertype, ix, iy, iw, ih, slabel) 
15206      return retval 
15207   
15208   
15209 -def fl_set_slider_value(pObject, val): 
15210      """ 
15211          fl_set_slider_value(pObject, val) 
15212   
15213          Changes the value of a slider. 
15214   
15215          @param pObject : pointer to object 
15216          @param val : new value of slider 
15217      """ 
15218   
15219      _fl_set_slider_value = cfuncproto( 
15220              load_so_libforms(), "fl_set_slider_value", 
15221              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15222              """void fl_set_slider_value(FL_OBJECT * ob, double val) 
15223              """) 
15224      fval = convert_to_double(val) 
15225      keep_elem_refs(pObject, val, fval) 
15226      _fl_set_slider_value(pObject, fval) 
15227   
15228   
15229 -def fl_get_slider_value(pObject): 
15230      """ 
15231          fl_get_slider_value(pObject) -> value[float] 
15232   
15233          Returns value of a slider. 
15234   
15235          @param pObject : pointer to object 
15236      """ 
15237   
15238      _fl_get_slider_value = cfuncproto( 
15239              load_so_libforms(), "fl_get_slider_value", 
15240              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15241              """double fl_get_slider_value(FL_OBJECT * ob) 
15242              """) 
15243      keep_elem_refs(pObject) 
15244      retval = _fl_get_slider_value(pObject) 
15245      return retval 
15246   
15247   
15248 -def fl_set_slider_bounds(pObject, minbound, maxbound): 
15249      """ 
15250          fl_set_slider_bounds(pObject, minbound, maxbound) 
15251   
15252          Sets bounds/limits of a slider. 
15253   
15254          @param pObject : pointer to object 
15255          @param minbound : minimum bound of slider 
15256          @param maxbound : maximum bound of slider 
15257      """ 
15258   
15259      _fl_set_slider_bounds = cfuncproto( 
15260              load_so_libforms(), "fl_set_slider_bounds", 
15261              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15262              """void fl_set_slider_bounds(FL_OBJECT * ob, double min, 
15263                 double max) 
15264              """) 
15265      fminbound = convert_to_double(minbound) 
15266      fmaxbound = convert_to_double(maxbound) 
15267      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
15268      _fl_set_slider_bounds(pObject, fminbound, fmaxbound) 
15269   
15270   
15271  #def fl_get_slider_bounds(pObject, minbound, maxbound)       *API change* 
15272 -def fl_get_slider_bounds(pObject): 
15273      """ 
15274          fl_get_slider_bounds(pObject) -> minbound[float], maxbound[float] 
15275   
15276          Returns bounds/limits of a slider. 
15277   
15278          @param pObject : pointer to object 
15279      """ 
15280   
15281      _fl_get_slider_bounds = cfuncproto( 
15282              load_so_libforms(), "fl_get_slider_bounds", 
15283              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15284              cty.POINTER(cty.c_double)], 
15285              """void fl_get_slider_bounds(FL_OBJECT * ob, double * min, 
15286                 double * max) 
15287              """) 
15288      minbound, pminbound = make_double_and_pointer() 
15289      maxbound, pmaxbound = make_double_and_pointer() 
15290      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
15291      _fl_get_slider_bounds(pObject, pminbound, pmaxbound) 
15292      return minbound, maxbound 
15293   
15294   
15295 -def fl_set_slider_return(pObject, returnnum): 
15296      """ 
15297          fl_set_slider_return(pObject, returnnum) 
15298   
15299          Sets the return value of a slider. 
15300   
15301          @param pObject : pointer to object 
15302          @param returnnum : value of return (e.g. xfc.FL_RETURN_NONE, etc..) 
15303      """ 
15304   
15305      _fl_set_slider_return = cfuncproto( 
15306              load_so_libforms(), "fl_set_slider_return", 
15307              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15308              """void fl_set_slider_return(FL_OBJECT * ob, int value) 
15309              """) 
15310      check_admitted_listvalues(returnnum, RETURN_list) 
15311      ireturnnum = convert_to_int(returnnum) 
15312      keep_elem_refs(pObject, returnnum, ireturnnum) 
15313      _fl_set_slider_return(pObject, ireturnnum) 
15314   
15315   
15316 -def fl_set_slider_step(pObject, value): 
15317      """ fl_set_slider_step(pObject, value) 
15318      """ 
15319   
15320      _fl_set_slider_step = cfuncproto( 
15321              load_so_libforms(), "fl_set_slider_step", 
15322              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15323              """void fl_set_slider_step(FL_OBJECT * ob, double value) 
15324              """) 
15325      fvalue = convert_to_double(value) 
15326      keep_elem_refs(pObject, value, fvalue) 
15327      _fl_set_slider_step(pObject, fvalue) 
15328   
15329   
15330 -def fl_set_slider_increment(pObject, leftbtnval, midlbtnval): 
15331      """ fl_set_slider_increment(pObject, leftbtnval, midlbtnval) 
15332      """ 
15333   
15334      _fl_set_slider_increment = cfuncproto( 
15335              load_so_libforms(), "fl_set_slider_increment", 
15336              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15337              """void fl_set_slider_increment(FL_OBJECT * ob, double l, 
15338                 double r) 
15339              """) 
15340      fleftbtnval = convert_to_double(leftbtnval) 
15341      fmidlbtnval = convert_to_double(midlbtnval) 
15342      keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, fmidlbtnval) 
15343      _fl_set_slider_increment(pObject, fleftbtnval, fmidlbtnval) 
15344   
15345   
15346  #def fl_get_slider_increment(pObject, leftbtnval, midlbtnval)       *API change* 
15347 -def fl_get_slider_increment(pObject): 
15348      """ fl_get_slider_increment(pObject) -> leftbtnval, midlbtnval 
15349      """ 
15350   
15351      _fl_get_slider_increment = cfuncproto( 
15352              load_so_libforms(), "fl_get_slider_increment", 
15353              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15354              cty.POINTER(cty.c_double)], \ 
15355              """void fl_get_slider_increment(FL_OBJECT * ob, double * l, 
15356                 double * r) 
15357              """) 
15358      leftbtnval, pleftbtnval = make_double_and_pointer() 
15359      midlbtnval, pmidlbtnval = make_double_and_pointer() 
15360      keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 
15361      _fl_get_slider_increment(pObject, pleftbtnval, pmidlbtnval) 
15362      return leftbtnval, midlbtnval 
15363   
15364   
15365 -def fl_set_slider_size(pObject, size): 
15366      """ 
15367          fl_set_slider_size(pObject, size) 
15368   
15369          Sets the size of a slider. 
15370   
15371          @param pObject : pointer to object 
15372          @param size : value of size of the slider 
15373      """ 
15374   
15375      _fl_set_slider_size = cfuncproto( 
15376              load_so_libforms(), "fl_set_slider_size", 
15377              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15378              """void fl_set_slider_size(FL_OBJECT * ob, double size) 
15379              """) 
15380      fsize = convert_to_double(size) 
15381      keep_elem_refs(pObject, size, fsize) 
15382      _fl_set_slider_size(pObject, fsize) 
15383   
15384   
15385 -def fl_set_slider_precision(pObject, precnum): 
15386      """ 
15387          fl_set_slider_precision(pObject, precnum) 
15388   
15389          Sets precision with which value a valslider is shown. 
15390   
15391          @param pObject : pointer to object 
15392          @param precnum : precision of shown value 
15393      """ 
15394   
15395      _fl_set_slider_precision = cfuncproto( 
15396              load_so_libforms(), "fl_set_slider_precision", 
15397              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15398              """void fl_set_slider_precision(FL_OBJECT * ob, int prec) 
15399              """) 
15400      iprecnum = convert_to_int(precnum) 
15401      keep_elem_refs(pObject, precnum, iprecnum) 
15402      _fl_set_slider_precision(pObject, iprecnum) 
15403   
15404   
15405 -def fl_set_slider_filter(pObject, py_ValFilter): 
15406      """ 
15407          fl_set_slider_filter(pObject, py_ValFilter) 
15408   
15409          Overrides the default (slider value shown in floating point format) 
15410          by registering a filter function. 
15411   
15412          @param pObject : pointer to oject 
15413          @param py_ValFilter : python function, fn(pObject, valfloat, 
15414             intprecis) -> string 
15415      """ 
15416   
15417      _fl_set_slider_filter = cfuncproto( 
15418              load_so_libforms(), "fl_set_slider_filter", 
15419              None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 
15420              """void fl_set_slider_filter(FL_OBJECT * ob, FL_VAL_FILTER filter) 
15421              """) 
15422      c_ValFilter = FL_VAL_FILTER(py_ValFilter) 
15423      keep_cfunc_refs(c_ValFilter, py_ValFilter) 
15424      keep_elem_refs(pObject) 
15425      _fl_set_slider_filter(pObject, c_ValFilter) 
15426   
15427   
15428 -def fl_create_spinner(spinnertype, x, y, w, h, label): 
15429      """ fl_create_spinner(spinnertype, x, y, w, h, label) -> pObject 
15430      """ 
15431   
15432      _fl_create_spinner = cfuncproto( 
15433              load_so_libforms(), "fl_create_spinner", 
15434              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15435              FL_Coord, STRING], 
15436              """FL_OBJECT * fl_create_spinner(int type, FL_Coord x, FL_Coord y, 
15437                 FL_Coord w, FL_Coord h, const char * label) 
15438              """) 
15439      check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 
15440      ispinnertype = convert_to_int(spinnertype) 
15441      ix = convert_to_FL_Coord(x) 
15442      iy = convert_to_FL_Coord(y) 
15443      iw = convert_to_FL_Coord(w) 
15444      ih = convert_to_FL_Coord(h) 
15445      slabel = convert_to_string(label) 
15446      keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 
15447                     iw, ih, slabel) 
15448      retval = _fl_create_spinner(ispinnertype, ix, iy, iw, ih, slabel) 
15449      return retval 
15450   
15451   
15452 -def fl_add_spinner(spinnertype, x, y, w, h, label): 
15453      """ fl_add_spinner(spinnertype, x, y, w, h, label) -> pObject 
15454      """ 
15455   
15456      _fl_add_spinner = cfuncproto( 
15457              load_so_libforms(), "fl_add_spinner", 
15458              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15459              FL_Coord, STRING], 
15460              """FL_OBJECT * fl_add_spinner(int type, FL_Coord x, FL_Coord y, 
15461              FL_Coord w, FL_Coord h, const char * label) 
15462              """) 
15463      check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 
15464      ispinnertype = convert_to_int(spinnertype) 
15465      ix = convert_to_FL_Coord(x) 
15466      iy = convert_to_FL_Coord(y) 
15467      iw = convert_to_FL_Coord(w) 
15468      ih = convert_to_FL_Coord(h) 
15469      slabel = convert_to_string(label) 
15470      keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 
15471                     iw, ih, slabel) 
15472      retval = _fl_add_spinner(ispinnertype, ix, iy, iw, ih, slabel) 
15473      return retval 
15474   
15475   
15476 -def fl_get_spinner_value(pObject): 
15477      """ fl_get_spinner_value(pObject) -> floatval 
15478      """ 
15479   
15480      _fl_get_spinner_value = cfuncproto( 
15481              load_so_libforms(), "fl_get_spinner_value", 
15482              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15483              """double fl_get_spinner_value(FL_OBJECT * obj) 
15484              """) 
15485      keep_elem_refs(pObject) 
15486      retval = _fl_get_spinner_value(pObject) 
15487      return retval 
15488   
15489   
15490 -def fl_set_spinner_value(pObject, val): 
15491      """ fl_set_spinner_value(pObject, val) -> num. 
15492      """ 
15493   
15494      _fl_set_spinner_value = cfuncproto( 
15495              load_so_libforms(), "fl_set_spinner_value", 
15496              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
15497              """double fl_set_spinner_value(FL_OBJECT * obj, double val) 
15498              """) 
15499      fval = convert_to_double(val) 
15500      keep_elem_refs(pObject, val, fval) 
15501      _fl_set_spinner_value(pObject, fval) 
15502   
15503   
15504 -def fl_set_spinner_bounds(pObject, minbound, maxbound): 
15505      """ fl_set_spinner_bounds(pObject, minbound, maxbound) 
15506      """ 
15507   
15508      _fl_set_spinner_bounds = cfuncproto( 
15509              load_so_libforms(), "fl_set_spinner_bounds", 
15510              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
15511              """void fl_set_spinner_bounds(FL_OBJECT * obj, double min, 
15512                 double max) 
15513              """) 
15514      fminbound = convert_to_double(minbound) 
15515      fmaxbound = convert_to_double(maxbound) 
15516      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
15517      _fl_set_spinner_bounds(pObject, fminbound, fmaxbound) 
15518   
15519   
15520  #def fl_get_spinner_bounds(pObject, minbound, maxbound):       *API change* 
15521 -def fl_get_spinner_bounds(pObject): 
15522      """ fl_get_spinner_bounds(pObject) -> minbound, maxbound 
15523      """ 
15524   
15525      _fl_get_spinner_bounds = cfuncproto( 
15526              load_so_libforms(), "fl_get_spinner_bounds", 
15527              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
15528              cty.POINTER(cty.c_double)], \ 
15529              """void fl_get_spinner_bounds(FL_OBJECT * obj, double * min, 
15530                 double * max) 
15531              """) 
15532      minbound, pminbound = make_double_and_pointer() 
15533      maxbound, pmaxbound = make_double_and_pointer() 
15534      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
15535      _fl_get_spinner_bounds(pObject, pminbound, pmaxbound) 
15536      return minbound, maxbound 
15537   
15538   
15539 -def fl_set_spinner_step(pObject, step): 
15540      """ fl_set_spinner_step(pObject, step) 
15541      """ 
15542   
15543      _fl_set_spinner_step = cfuncproto( 
15544              load_so_libforms(), "fl_set_spinner_step", 
15545              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
15546              """void fl_set_spinner_step(FL_OBJECT * obj, double step) 
15547              """) 
15548      fstep = convert_to_double(step) 
15549      keep_elem_refs(pObject, step, fstep) 
15550      _fl_set_spinner_step(pObject, fstep) 
15551   
15552   
15553 -def fl_get_spinner_step(pObject): 
15554      """ fl_get_spinner_step(pObject) -> num. 
15555      """ 
15556   
15557      _fl_get_spinner_step = cfuncproto( 
15558              load_so_libforms(), "fl_get_spinner_step", 
15559              cty.c_double, [cty.POINTER(FL_OBJECT)], 
15560              """double fl_get_spinner_step(FL_OBJECT * obj) 
15561              """) 
15562      keep_elem_refs(pObject) 
15563      retval = _fl_get_spinner_step(pObject) 
15564      return retval 
15565   
15566   
15567 -def fl_set_spinner_precision(pObject, precnum): 
15568      """ fl_set_spinner_precision(pObject, precnum) 
15569      """ 
15570   
15571      _fl_set_spinner_precision = cfuncproto( 
15572              load_so_libforms(), "fl_set_spinner_precision", 
15573              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15574              """void fl_set_spinner_precision(FL_OBJECT * obj, int prec) 
15575              """) 
15576      iprecnum = convert_to_int(precnum) 
15577      keep_elem_refs(pObject, precnum, iprecnum) 
15578      _fl_set_spinner_precision(pObject, iprecnum) 
15579   
15580   
15581 -def fl_get_spinner_precision(pObject): 
15582      """ fl_get_spinner_precision(pObject) -> num. 
15583      """ 
15584   
15585      _fl_get_spinner_precision = cfuncproto( 
15586              load_so_libforms(), "fl_get_spinner_precision", 
15587              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15588              """int fl_get_spinner_precision(FL_OBJECT * obj) 
15589              """) 
15590      keep_elem_refs(pObject) 
15591      retval = _fl_get_spinner_precision(pObject) 
15592      return retval 
15593   
15594   
15595 -def fl_get_spinner_input(pObject): 
15596      """ fl_get_spinner_input(pObject) -> pObject 
15597      """ 
15598   
15599      _fl_get_spinner_input = cfuncproto( 
15600              load_so_libforms(), "fl_get_spinner_input", 
15601              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15602              """FL_OBJECT * fl_get_spinner_input(FL_OBJECT * obj) 
15603              """) 
15604      keep_elem_refs(pObject) 
15605      retval = _fl_get_spinner_input(pObject) 
15606      return retval 
15607   
15608   
15609 -def fl_get_spinner_up_button(pObject): 
15610      """ fl_get_spinner_up_button(pObject) -> pObject 
15611      """ 
15612   
15613      _fl_get_spinner_up_button = cfuncproto( 
15614              load_so_libforms(), "fl_get_spinner_up_button", 
15615              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15616              """FL_OBJECT * fl_get_spinner_up_button(FL_OBJECT * obj) 
15617              """) 
15618      keep_elem_refs(pObject) 
15619      retval = _fl_get_spinner_up_button(pObject) 
15620      return retval 
15621   
15622   
15623 -def fl_get_spinner_down_button(pObject): 
15624      """ fl_get_spinner_down_button(pObject) -> pObject 
15625      """ 
15626   
15627      _fl_get_spinner_down_button = cfuncproto( 
15628              load_so_libforms(), "fl_get_spinner_down_button", 
15629              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 
15630              """FL_OBJECT * fl_get_spinner_down_button(FL_OBJECT * obj) 
15631              """) 
15632      keep_elem_refs(pObject) 
15633      retval = _fl_get_spinner_down_button(pObject) 
15634      return retval 
15635   
15636   
15637   
15638  ######################## 
15639  # forms.h (tabfolder.h) 
15640  ######################## 
15641   
15642 -def fl_create_tabfolder(foldertype, x, y, w, h, label): 
15643      """ fl_create_tabfolder(foldertype, x, y, w, h, label) -> pObject 
15644      """ 
15645   
15646      _fl_create_tabfolder = cfuncproto( 
15647              load_so_libforms(), "fl_create_tabfolder", 
15648              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15649              FL_Coord, STRING], 
15650              """FL_OBJECT * fl_create_tabfolder(int type, FL_Coord x, 
15651                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
15652              """) 
15653      check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 
15654      ifoldertype = convert_to_int(foldertype) 
15655      ix = convert_to_FL_Coord(x) 
15656      iy = convert_to_FL_Coord(y) 
15657      iw = convert_to_FL_Coord(w) 
15658      ih = convert_to_FL_Coord(h) 
15659      slabel = convert_to_string(label) 
15660      keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 
15661                     iw, ih, slabel) 
15662      retval = _fl_create_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 
15663      return retval 
15664   
15665   
15666 -def fl_add_tabfolder(foldertype, x, y, w, h, label): 
15667      """ fl_add_tabfolder(foldertype, x, y, w, h, label) -> pObject 
15668      """ 
15669   
15670      _fl_add_tabfolder = cfuncproto( 
15671              load_so_libforms(), "fl_add_tabfolder", 
15672              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
15673              FL_Coord, STRING], 
15674              """FL_OBJECT * fl_add_tabfolder(int type, FL_Coord x, FL_Coord y, 
15675                 FL_Coord w, FL_Coord h, const char * label) 
15676              """) 
15677      check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 
15678      ifoldertype = convert_to_int(foldertype) 
15679      ix = convert_to_FL_Coord(x) 
15680      iy = convert_to_FL_Coord(y) 
15681      iw = convert_to_FL_Coord(w) 
15682      ih = convert_to_FL_Coord(h) 
15683      slabel = convert_to_string(label) 
15684      keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 
15685                     iw, ih, slabel) 
15686      retval = _fl_add_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 
15687      return retval 
15688   
15689   
15690 -def fl_addto_tabfolder(pObject, title, pForm): 
15691      """ fl_addto_tabfolder(pObject, title, pForm) -> pObject 
15692      """ 
15693   
15694      _fl_addto_tabfolder = cfuncproto( 
15695              load_so_libforms(), "fl_addto_tabfolder", 
15696              cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), STRING, 
15697              cty.POINTER(FL_FORM)], 
15698              """FL_OBJECT * fl_addto_tabfolder(FL_OBJECT * ob, 
15699                 const char * title, FL_FORM * form) 
15700              """) 
15701      stitle = convert_to_string(title) 
15702      keep_elem_refs(pObject, title, pForm, stitle) 
15703      retval = _fl_addto_tabfolder(pObject, stitle, pForm) 
15704      return retval 
15705   
15706   
15707 -def fl_get_tabfolder_folder_bynumber(pObject, num): 
15708      """ fl_get_tabfolder_folder_bynumber(pObject, num) -> pForm 
15709      """ 
15710   
15711      _fl_get_tabfolder_folder_bynumber = cfuncproto( 
15712              load_so_libforms(), "fl_get_tabfolder_folder_bynumber", 
15713              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 
15714              """FL_FORM * fl_get_tabfolder_folder_bynumber(FL_OBJECT * ob, 
15715                 int num) 
15716              """) 
15717      inum = convert_to_int(num) 
15718      keep_elem_refs(pObject, num, inum) 
15719      retval = _fl_get_tabfolder_folder_bynumber(pObject, inum) 
15720      return retval 
15721   
15722   
15723 -def fl_get_tabfolder_folder_byname(pObject, name): 
15724      """ fl_get_tabfolder_folder_byname(pObject, name) -> pForm 
15725      """ 
15726   
15727      _fl_get_tabfolder_folder_byname = cfuncproto( 
15728              load_so_libforms(), "fl_get_tabfolder_folder_byname", 
15729              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), STRING], 
15730              """FL_FORM * fl_get_tabfolder_folder_byname(FL_OBJECT * ob, 
15731                 const char * name) 
15732              """) 
15733      sname = convert_to_string(name) 
15734      keep_elem_refs(pObject, name, sname) 
15735      retval = _fl_get_tabfolder_folder_byname(pObject, sname) 
15736      return retval 
15737   
15738   
15739 -def fl_delete_folder(pObject, pForm): 
15740      """ fl_delete_folder(pObject, pForm) 
15741      """ 
15742   
15743      _fl_delete_folder = cfuncproto( 
15744              load_so_libforms(), "fl_delete_folder", 
15745              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
15746              """void fl_delete_folder(FL_OBJECT * ob, FL_FORM * form) 
15747              """) 
15748      keep_elem_refs(pObject, pForm) 
15749      _fl_delete_folder(pObject, pForm) 
15750   
15751   
15752 -def fl_delete_folder_bynumber(pObject, num): 
15753      """ fl_delete_folder_bynumber(pObject, num) 
15754      """ 
15755   
15756      _fl_delete_folder_bynumber = cfuncproto( 
15757              load_so_libforms(), "fl_delete_folder_bynumber", 
15758              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15759              """void fl_delete_folder_bynumber(FL_OBJECT * ob, int num) 
15760              """) 
15761      inum = convert_to_int(num) 
15762      keep_elem_refs(pObject, num, inum) 
15763      _fl_delete_folder_bynumber(pObject, inum) 
15764   
15765   
15766 -def fl_delete_folder_byname(pObject, name): 
15767      """ fl_delete_folder_byname(pObject, name) 
15768      """ 
15769   
15770      _fl_delete_folder_byname = cfuncproto( 
15771              load_so_libforms(), "fl_delete_folder_byname", 
15772              None, [cty.POINTER(FL_OBJECT), STRING], 
15773              """void fl_delete_folder_byname(FL_OBJECT * ob, const char * name) 
15774              """) 
15775      sname = convert_to_string(name) 
15776      keep_elem_refs(pObject, name, sname) 
15777      _fl_delete_folder_byname(pObject, sname) 
15778   
15779   
15780 -def fl_set_folder(pObject, pForm): 
15781      """ fl_set_folder(pObject, pForm) 
15782      """ 
15783   
15784      _fl_set_folder = cfuncproto( 
15785              load_so_libforms(), "fl_set_folder", 
15786              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 
15787              """void fl_set_folder(FL_OBJECT * ob, FL_FORM * form) 
15788              """) 
15789      keep_elem_refs(pObject, pForm) 
15790      _fl_set_folder(pObject, pForm) 
15791   
15792   
15793 -def fl_set_folder_byname(pObject, name): 
15794      """ fl_set_folder_byname(pObject, name) 
15795      """ 
15796   
15797      _fl_set_folder_byname = cfuncproto( 
15798              load_so_libforms(), "fl_set_folder_byname", 
15799              None, [cty.POINTER(FL_OBJECT), STRING], 
15800              """void fl_set_folder_byname(FL_OBJECT * ob, const char * name) 
15801              """) 
15802      sname = convert_to_string(name) 
15803      keep_elem_refs(pObject, name, sname) 
15804      _fl_set_folder_byname(pObject, name) 
15805   
15806   
15807 -def fl_set_folder_bynumber(pObject, num): 
15808      """ fl_set_folder_bynumber(pObject, num) 
15809      """ 
15810   
15811      _fl_set_folder_bynumber = cfuncproto( 
15812              load_so_libforms(), "fl_set_folder_bynumber", 
15813              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
15814              """void fl_set_folder_bynumber(FL_OBJECT * ob, int num) 
15815              """) 
15816      inum = convert_to_int(num) 
15817      keep_elem_refs(pObject, num, inum) 
15818      _fl_set_folder_bynumber(pObject, inum) 
15819   
15820   
15821 -def fl_get_folder(pObject): 
15822      """ 
15823          fl_get_folder(pObject) -> pForm 
15824   
15825          @param pObject : pointer to object 
15826      """ 
15827   
15828      _fl_get_folder = cfuncproto( 
15829              load_so_libforms(), "fl_get_folder", 
15830              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
15831              """FL_FORM * fl_get_folder(FL_OBJECT * ob) 
15832              """) 
15833      keep_elem_refs(pObject) 
15834      retval = _fl_get_folder(pObject) 
15835      return retval 
15836   
15837   
15838 -def fl_get_folder_number(pObject): 
15839      """ 
15840          fl_get_folder_number(pObject) -> folder num. 
15841   
15842          @param pObject : pointer to object 
15843      """ 
15844   
15845      _fl_get_folder_number = cfuncproto( 
15846              load_so_libforms(), "fl_get_folder_number", 
15847              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15848              """int fl_get_folder_number(FL_OBJECT * ob) 
15849              """) 
15850      keep_elem_refs(pObject) 
15851      retval = _fl_get_folder_number(pObject) 
15852      return retval 
15853   
15854   
15855 -def fl_get_folder_name(pObject): 
15856      """ 
15857          fl_get_folder_name(pObject) -> name string 
15858   
15859          @param pObject : pointer to object 
15860      """ 
15861   
15862      _fl_get_folder_name = cfuncproto( 
15863              load_so_libforms(), "fl_get_folder_name", 
15864              STRING, [cty.POINTER(FL_OBJECT)], 
15865              """const char * fl_get_folder_name(FL_OBJECT * ob) 
15866              """) 
15867      keep_elem_refs(pObject) 
15868      retval = _fl_get_folder_name(pObject) 
15869      return retval 
15870   
15871   
15872 -def fl_get_tabfolder_numfolders(pObject): 
15873      """ 
15874          fl_get_tabfolder_numfolders(pObject) -> num. 
15875   
15876          @param pObject : pointer to object 
15877      """ 
15878   
15879      _fl_get_tabfolder_numfolders = cfuncproto( 
15880              load_so_libforms(), "fl_get_tabfolder_numfolders", 
15881              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15882              """int fl_get_tabfolder_numfolders(FL_OBJECT * ob) 
15883              """) 
15884      keep_elem_refs(pObject) 
15885      retval = _fl_get_tabfolder_numfolders(pObject) 
15886      return retval 
15887   
15888   
15889 -def fl_get_active_folder(pObject): 
15890      """ 
15891          fl_get_active_folder(pObject) -> pForm 
15892   
15893          @param pObject : pointer to object 
15894      """ 
15895   
15896      _fl_get_active_folder = cfuncproto( 
15897              load_so_libforms(), "fl_get_active_folder", 
15898              cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 
15899              """FL_FORM * fl_get_active_folder(FL_OBJECT * ob) 
15900              """) 
15901      keep_elem_refs(pObject) 
15902      retval = _fl_get_active_folder(pObject) 
15903      return retval 
15904   
15905   
15906 -def fl_get_active_folder_number(pObject): 
15907      """ 
15908          fl_get_active_folder_number(pObject) -> num. 
15909   
15910          @param pObject : pointer to object 
15911      """ 
15912   
15913      _fl_get_active_folder_number = cfuncproto( 
15914              load_so_libforms(), "fl_get_active_folder_number", 
15915              cty.c_int, [cty.POINTER(FL_OBJECT)], 
15916              """int fl_get_active_folder_number(FL_OBJECT * ob) 
15917              """) 
15918      keep_elem_refs(pObject) 
15919      retval = _fl_get_active_folder_number(pObject) 
15920      return retval 
15921   
15922   
15923 -def fl_get_active_folder_name(pObject): 
15924      """ 
15925          fl_get_active_folder_name(pObject) -> name string 
15926   
15927          @param pObject : pointer to object 
15928      """ 
15929   
15930      _fl_get_active_folder_name = cfuncproto( 
15931              load_so_libforms(), "fl_get_active_folder_name", 
15932              STRING, [cty.POINTER(FL_OBJECT)], 
15933              """const char * fl_get_active_folder_name(FL_OBJECT * ob) 
15934              """) 
15935      keep_elem_refs(pObject) 
15936      retval = _fl_get_active_folder_name(pObject) 
15937      return retval 
15938   
15939   
15940  #def fl_get_folder_area(pObject, x, y, w, h)       *API change* 
15941 -def fl_get_folder_area(pObject): 
15942      """ 
15943          fl_get_folder_area(pObject) -> x, y, w, h 
15944   
15945          @param pObject : pointer to object 
15946      """ 
15947   
15948      _fl_get_folder_area = cfuncproto( 
15949              load_so_libforms(), "fl_get_folder_area", 
15950              None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 
15951              cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 
15952              cty.POINTER(FL_Coord)], 
15953              """void fl_get_folder_area(FL_OBJECT * ob, FL_Coord * x, 
15954                 FL_Coord * y, FL_Coord * w, FL_Coord * h) 
15955              """) 
15956      x, px = make_int_and_pointer() 
15957      y, py = make_int_and_pointer() 
15958      w, pw = make_int_and_pointer() 
15959      h, ph = make_int_and_pointer() 
15960      keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 
15961      _fl_get_folder_area(pObject, px, py, pw, ph) 
15962      return x, y, w, h 
15963   
15964   
15965 -def fl_replace_folder_bynumber(pObject, num, pForm): 
15966      """ 
15967          fl_replace_folder_bynumber(pObject, num, pForm) 
15968   
15969          @param pObject : pointer to object 
15970      """ 
15971   
15972      _fl_replace_folder_bynumber = cfuncproto( 
15973              load_so_libforms(), "fl_replace_folder_bynumber", 
15974              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(FL_FORM)], 
15975              """void fl_replace_folder_bynumber(FL_OBJECT * ob, int num, 
15976                 FL_FORM * form) 
15977              """) 
15978      inum = convert_to_int(num) 
15979      keep_elem_refs(pObject, num, pForm, inum) 
15980      _fl_replace_folder_bynumber(pObject, inum, pForm) 
15981   
15982   
15983 -def fl_set_tabfolder_autofit(pObject, num): 
15984      """ 
15985          fl_set_tabfolder_autofit(pObject, num) -> num. 
15986   
15987          @param pObject : pointer to object 
15988      """ 
15989   
15990      _fl_set_tabfolder_autofit = cfuncproto( 
15991              load_so_libforms(), "fl_set_tabfolder_autofit", 
15992              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
15993              """int fl_set_tabfolder_autofit(FL_OBJECT * ob, int y) 
15994              """) 
15995      inum = convert_to_int(num) 
15996      keep_elem_refs(pObject, num, inum) 
15997      retval = _fl_set_tabfolder_autofit(pObject, inum) 
15998      return retval 
15999   
16000   
16001 -def fl_set_default_tabfolder_corner(npixels): 
16002      """ 
16003          fl_set_default_tabfolder_corner(npixels) -> old pixels num. 
16004   
16005          Adjusts the corner pixels, changing appearance of the tabs. 
16006   
16007          @param npixels : number of corner pixels (default 3) 
16008      """ 
16009   
16010      _fl_set_default_tabfolder_corner = cfuncproto( 
16011              load_so_libforms(), "fl_set_default_tabfolder_corner", 
16012              cty.c_int, [cty.c_int], 
16013              """int fl_set_default_tabfolder_corner(int n): 
16014              """) 
16015      ipixels = convert_to_int(npixels) 
16016      keep_elem_refs(npixels, ipixels) 
16017      retval = _fl_set_default_tabfolder_corner(ipixels) 
16018      return retval 
16019   
16020   
16021 -def fl_set_tabfolder_offset(pObject, offset): 
16022      """ 
16023          fl_set_tabfolder_offset(pObject, offset) -> num. 
16024   
16025          @param pObject : pointer to tabfolder object 
16026      """ 
16027   
16028      _fl_set_tabfolder_offset = cfuncproto( 
16029              load_so_libforms(), "fl_set_tabfolder_offset", 
16030              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
16031              """int fl_set_tabfolder_offset(FL_OBJECT * ob, int offset) 
16032              """) 
16033      ioffset = convert_to_int(offset) 
16034      keep_elem_refs(pObject, offset, ioffset) 
16035      retval = _fl_set_tabfolder_offset(pObject, ioffset) 
16036      return retval 
16037   
16038   
16039   
16040  ################### 
16041  # forms.h (text.h) 
16042  ################### 
16043   
16044 -def fl_create_text(texttype, x, y, w, h, label): 
16045      """ 
16046          fl_create_text(texttype, x, y, w, h, label) -> pObject 
16047      """ 
16048   
16049      _fl_create_text = cfuncproto( 
16050              load_so_libforms(), "fl_create_text", 
16051              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16052              FL_Coord, STRING], 
16053              """FL_OBJECT * fl_create_text(int type, FL_Coord x, FL_Coord y, 
16054                 FL_Coord w, FL_Coord h, const char * label) 
16055              """) 
16056      check_admitted_listvalues(texttype, TEXTTYPE_list) 
16057      itexttype = convert_to_int(texttype) 
16058      ix = convert_to_FL_Coord(x) 
16059      iy = convert_to_FL_Coord(y) 
16060      iw = convert_to_FL_Coord(w) 
16061      ih = convert_to_FL_Coord(h) 
16062      slabel = convert_to_string(label) 
16063      keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 
16064                     iw, ih, slabel) 
16065      retval = _fl_create_text(itexttype, ix, iy, iw, ih, slabel) 
16066      return retval 
16067   
16068   
16069 -def fl_add_text(texttype, x, y, w, h, label): 
16070      """ 
16071          fl_add_text(texttype, x, y, w, h, label) -> pObject 
16072      """ 
16073   
16074      _fl_add_text = cfuncproto( 
16075              load_so_libforms(), "fl_add_text", 
16076              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16077              FL_Coord, STRING], 
16078              """FL_OBJECT * fl_add_text(int type, FL_Coord x, FL_Coord y, 
16079                 FL_Coord w, FL_Coord h, const char * label) 
16080              """) 
16081      check_admitted_listvalues(texttype, TEXTTYPE_list) 
16082      itexttype = convert_to_int(texttype) 
16083      ix = convert_to_FL_Coord(x) 
16084      iy = convert_to_FL_Coord(y) 
16085      iw = convert_to_FL_Coord(w) 
16086      ih = convert_to_FL_Coord(h) 
16087      slabel = convert_to_string(label) 
16088      keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 
16089                     iw, ih, slabel) 
16090      retval = _fl_add_text(itexttype, ix, iy, iw, ih, slabel) 
16091      return retval 
16092   
16093   
16094   
16095  ######################### 
16096  # forms.h (thumbwheel.h) 
16097  ######################### 
16098   
16099 -def fl_get_thumbwheel_value(pObject): 
16100      """ 
16101          fl_get_thumbwheel_value(pObject) -> num. 
16102   
16103          @param pObject : pointer to object 
16104      """ 
16105   
16106      _fl_get_thumbwheel_value = cfuncproto( 
16107              load_so_libforms(), "fl_get_thumbwheel_value", 
16108              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16109              """double fl_get_thumbwheel_value(FL_OBJECT * ob) 
16110              """) 
16111      keep_elem_refs(pObject) 
16112      retval = _fl_get_thumbwheel_value(pObject) 
16113      return retval 
16114   
16115   
16116 -def fl_set_thumbwheel_value(pObject, value): 
16117      """ 
16118          fl_set_thumbwheel_value(pObject, value) 
16119   
16120          @param pObject : pointer to object 
16121      """ 
16122   
16123      _fl_set_thumbwheel_value = cfuncproto( 
16124              load_so_libforms(), "fl_set_thumbwheel_value", 
16125              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
16126              """double fl_set_thumbwheel_value(FL_OBJECT * ob, double value) 
16127              """) 
16128      fvalue = convert_to_double(value) 
16129      keep_elem_refs(pObject, value, fvalue) 
16130      retval = _fl_set_thumbwheel_value(pObject, fvalue) 
16131      return retval 
16132   
16133   
16134 -def fl_get_thumbwheel_step(pObject): 
16135      """ 
16136          fl_get_thumbwheel_step(pObject) -> num. 
16137   
16138          @param pObject : pointer to object 
16139      """ 
16140   
16141      _fl_get_thumbwheel_step = cfuncproto( 
16142              load_so_libforms(), "fl_get_thumbwheel_step", 
16143              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16144              """double fl_get_thumbwheel_step(FL_OBJECT * ob) 
16145              """) 
16146      keep_elem_refs(pObject) 
16147      retval = _fl_get_thumbwheel_step(pObject) 
16148      return retval 
16149   
16150   
16151 -def fl_set_thumbwheel_step(pObject, step): 
16152      """ 
16153          fl_set_thumbwheel_step(pObject, step) -> num. 
16154   
16155          @param pObject : pointer to object 
16156      """ 
16157   
16158      _fl_set_thumbwheel_step = cfuncproto( 
16159              load_so_libforms(), "fl_set_thumbwheel_step", 
16160              cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 
16161              """double fl_set_thumbwheel_step(FL_OBJECT * ob, double step) 
16162              """) 
16163      fstep = convert_to_double(step) 
16164      keep_elem_refs(pObject, step, fstep) 
16165      retval = _fl_set_thumbwheel_step(pObject, fstep) 
16166      return retval 
16167   
16168   
16169 -def fl_set_thumbwheel_return(pObject, when): 
16170      """ 
16171          fl_set_thumbwheel_return(pObject, when) -> num. 
16172   
16173          @param pObject : pointer to object 
16174      """ 
16175   
16176      _fl_set_thumbwheel_return = cfuncproto( 
16177              load_so_libforms(), "fl_set_thumbwheel_return", 
16178              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
16179              """int fl_set_thumbwheel_return(FL_OBJECT * ob, int how) 
16180              """) 
16181      check_admitted_listvalues(when, RETURN_list) 
16182      iwhen = convert_to_int(when) 
16183      keep_elem_refs(pObject, when, iwhen) 
16184      retval = _fl_set_thumbwheel_return(pObject, when) 
16185      return retval 
16186   
16187   
16188 -def fl_set_thumbwheel_crossover(pObject, flag): 
16189      """ 
16190          fl_set_thumbwheel_crossover(pObject, flag) -> num. 
16191   
16192          @param pObject : pointer to object 
16193      """ 
16194   
16195      _fl_set_thumbwheel_crossover = cfuncproto( 
16196              load_so_libforms(), "fl_set_thumbwheel_crossover", 
16197              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
16198              """int fl_set_thumbwheel_crossover(FL_OBJECT * ob, int flag) 
16199              """) 
16200      iflag = convert_to_int(flag) 
16201      keep_elem_refs(pObject, flag, iflag) 
16202      retval = _fl_set_thumbwheel_crossover(pObject, iflag) 
16203      return retval 
16204   
16205   
16206 -def fl_set_thumbwheel_bounds(pObject, minbound, maxbound): 
16207      """ 
16208          fl_set_thumbwheel_bounds(pObject, minbound, maxbound) 
16209   
16210          @param pObject : pointer to object 
16211      """ 
16212   
16213      _fl_set_thumbwheel_bounds = cfuncproto( 
16214              load_so_libforms(), "fl_set_thumbwheel_bounds", 
16215              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
16216              """void fl_set_thumbwheel_bounds(FL_OBJECT * ob, double min, 
16217                 double max) 
16218              """) 
16219      fminbound = convert_to_double(minbound) 
16220      fmaxbound = convert_to_double(maxbound) 
16221      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
16222      _fl_set_thumbwheel_bounds(pObject, fminbound, fmaxbound) 
16223   
16224   
16225  #def fl_get_thumbwheel_bounds(pObject, minbound, maxbound)       *API change* 
16226 -def fl_get_thumbwheel_bounds(pObject): 
16227      """ 
16228          fl_get_thumbwheel_bounds(pObject) -> minbound, maxbound 
16229   
16230          @param pObject : pointer to thumbwheel object 
16231      """ 
16232   
16233      _fl_get_thumbwheel_bounds = cfuncproto( 
16234              load_so_libforms(), "fl_get_thumbwheel_bounds", 
16235              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
16236              cty.POINTER(cty.c_double)], 
16237              """void fl_get_thumbwheel_bounds(FL_OBJECT * ob, double * min, 
16238                 double * max) 
16239              """) 
16240      minbound, pminbound = make_double_and_pointer() 
16241      maxbound, pmaxbound = make_double_and_pointer() 
16242      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
16243      _fl_get_thumbwheel_bounds(pObject, pminbound, pmaxbound) 
16244      return minbound, maxbound 
16245   
16246   
16247 -def fl_create_thumbwheel(wheeltype, x, y, w, h, label): 
16248      """ 
16249          fl_create_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 
16250      """ 
16251   
16252      _fl_create_thumbwheel = cfuncproto( 
16253              load_so_libforms(), "fl_create_thumbwheel", 
16254              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16255              FL_Coord, STRING], 
16256              """FL_OBJECT * fl_create_thumbwheel(int type, FL_Coord x, 
16257                 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 
16258              """) 
16259      check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 
16260      iwheeltype = convert_to_int(wheeltype) 
16261      ix = convert_to_FL_Coord(x) 
16262      iy = convert_to_FL_Coord(y) 
16263      iw = convert_to_FL_Coord(w) 
16264      ih = convert_to_FL_Coord(h) 
16265      slabel = convert_to_string(label) 
16266      keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 
16267                     iw, ih, slabel) 
16268      retval = _fl_create_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 
16269      return retval 
16270   
16271   
16272 -def fl_add_thumbwheel(wheeltype, x, y, w, h, label): 
16273      """ 
16274          fl_add_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 
16275      """ 
16276   
16277      _fl_add_thumbwheel = cfuncproto( 
16278              load_so_libforms(), "fl_add_thumbwheel", 
16279              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16280              FL_Coord, STRING], 
16281              """FL_OBJECT * fl_add_thumbwheel(int type, FL_Coord x, FL_Coord y, 
16282                 FL_Coord w, FL_Coord h, const char * label) 
16283              """) 
16284      check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 
16285      iwheeltype = convert_to_int(wheeltype) 
16286      ix = convert_to_FL_Coord(x) 
16287      iy = convert_to_FL_Coord(y) 
16288      iw = convert_to_FL_Coord(w) 
16289      ih = convert_to_FL_Coord(h) 
16290      slabel = convert_to_string(label) 
16291      keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 
16292                     iw, ih, slabel) 
16293      retval = _fl_add_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 
16294      return retval 
16295   
16296   
16297   
16298  ###################### 
16299  # forms.h (timer.h) 
16300  # Object Class: Timer 
16301  ###################### 
16302   
16303  # Routines 
16304   
16305 -def fl_create_timer(timertype, x, y, w, h, label): 
16306      """ 
16307          fl_create_timer(timertype, x, y, w, h, label) -> pObject 
16308      """ 
16309   
16310      _fl_create_timer = cfuncproto( 
16311              load_so_libforms(), "fl_create_timer", 
16312              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16313              FL_Coord, STRING], 
16314              """FL_OBJECT * fl_create_timer(int type, FL_Coord x, FL_Coord y, 
16315              FL_Coord w, FL_Coord h, const char * label) 
16316              """) 
16317      check_admitted_listvalues(timertype, TIMERTYPE_list) 
16318      itimertype = convert_to_int(timertype) 
16319      ix = convert_to_FL_Coord(x) 
16320      iy = convert_to_FL_Coord(y) 
16321      iw = convert_to_FL_Coord(w) 
16322      ih = convert_to_FL_Coord(h) 
16323      slabel = convert_to_string(label) 
16324      keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 
16325                     iw, ih, slabel) 
16326      retval = _fl_create_timer(itimertype, ix, iy, iw, ih, slabel) 
16327      return retval 
16328   
16329   
16330 -def fl_add_timer(timertype, x, y, w, h, label): 
16331      """ 
16332          fl_add_timer(timertype, x, y, w, h, label) -> pObject 
16333      """ 
16334   
16335      _fl_add_timer = cfuncproto( 
16336              load_so_libforms(), "fl_add_timer", 
16337              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
16338              FL_Coord, STRING], 
16339              """FL_OBJECT * fl_add_timer(int type, FL_Coord x, FL_Coord y, 
16340              FL_Coord w, FL_Coord h, const char * label) 
16341              """) 
16342      check_admitted_listvalues(timertype, TIMERTYPE_list) 
16343      itimertype = convert_to_int(timertype) 
16344      ix = convert_to_FL_Coord(x) 
16345      iy = convert_to_FL_Coord(y) 
16346      iw = convert_to_FL_Coord(w) 
16347      ih = convert_to_FL_Coord(h) 
16348      slabel = convert_to_string(label) 
16349      keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 
16350                     iw, ih, slabel) 
16351      retval = _fl_add_timer(itimertype, ix, iy, iw, ih, slabel) 
16352      return retval 
16353   
16354   
16355 -def fl_set_timer(pObject, total): 
16356      """ 
16357          fl_set_timer(pObject, total) 
16358   
16359          @param pObject : pointer to object 
16360      """ 
16361   
16362      _fl_set_timer = cfuncproto( 
16363              load_so_libforms(), "fl_set_timer", 
16364              None, [cty.POINTER(FL_OBJECT), cty.c_double], 
16365              """void fl_set_timer(FL_OBJECT * ob, double total) 
16366              """) 
16367      ftotal = convert_to_double(total) 
16368      keep_elem_refs(pObject, total, ftotal) 
16369      _fl_set_timer(pObject, ftotal) 
16370   
16371   
16372 -def fl_get_timer(pObject): 
16373      """ 
16374          fl_get_timer(pObject) -> num. 
16375   
16376          @param pObject : pointer to object 
16377      """ 
16378   
16379      _fl_get_timer = cfuncproto( 
16380              load_so_libforms(), "fl_get_timer", 
16381              cty.c_double, [cty.POINTER(FL_OBJECT)], 
16382              """double fl_get_timer(FL_OBJECT * ob) 
16383              """) 
16384      keep_elem_refs(pObject) 
16385      retval = _fl_get_timer(pObject) 
16386      return retval 
16387   
16388   
16389 -def fl_set_timer_countup(pObject, yes): 
16390      """ 
16391          fl_set_timer_countup(pObject, yes) 
16392   
16393          @param pObject : pointer to object 
16394      """ 
16395   
16396      _fl_set_timer_countup = cfuncproto( 
16397              load_so_libforms(), "fl_set_timer_countup", 
16398              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
16399              """void fl_set_timer_countup(FL_OBJECT * ob, int yes) 
16400              """) 
16401      iyes = convert_to_int(yes) 
16402      keep_elem_refs(pObject, yes, iyes) 
16403      _fl_set_timer_countup(pObject, iyes) 
16404   
16405   
16406  FL_TIMER_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double) 
16407   
16408 -def fl_set_timer_filter(pObject, py_TimerFilter): 
16409      """ 
16410          fl_set_timer_filter(pObject, py_TimerFilter) -> timer_filter func. 
16411   
16412          @param pObject : pointer to object 
16413          @param py_TimerFilter : python function, fn(pObject, valfloat) -> 
16414             string 
16415      """ 
16416   
16417      _fl_set_timer_filter = cfuncproto( 
16418              load_so_libforms(), "fl_set_timer_filter", 
16419              FL_TIMER_FILTER, [cty.POINTER(FL_OBJECT), FL_TIMER_FILTER], 
16420              """FL_TIMER_FILTER fl_set_timer_filter(FL_OBJECT * ob, 
16421                 FL_TIMER_FILTER filter) 
16422              """) 
16423      c_TimerFilter = FL_TIMER_FILTER(py_TimerFilter) 
16424      keep_cfunc_refs(c_TimerFilter, py_TimerFilter) 
16425      keep_elem_refs(pObject) 
16426      retval = _fl_set_timer_filter(pObject, c_TimerFilter) 
16427      return retval 
16428   
16429   
16430 -def fl_suspend_timer(pObject): 
16431      """ 
16432          fl_suspend_timer(pObject) 
16433   
16434          @param pObject : pointer to object 
16435      """ 
16436   
16437      _fl_suspend_timer = cfuncproto( 
16438              load_so_libforms(), "fl_suspend_timer", 
16439              None, [cty.POINTER(FL_OBJECT)], 
16440              """void fl_suspend_timer(FL_OBJECT * ob) 
16441              """) 
16442      keep_elem_refs(pObject) 
16443      _fl_suspend_timer(pObject) 
16444   
16445   
16446 -def fl_resume_timer(pObject): 
16447      """ 
16448          fl_resume_timer(pObject) 
16449   
16450          Resume timer previously paused. 
16451   
16452          @param pObject : pointer to timer object 
16453      """ 
16454   
16455      _fl_resume_timer = cfuncproto( 
16456              load_so_libforms(), "fl_resume_timer", 
16457              None, [cty.POINTER(FL_OBJECT)], 
16458              """void fl_resume_timer(FL_OBJECT * ob) 
16459              """) 
16460      keep_elem_refs(pObject) 
16461      _fl_resume_timer(pObject) 
16462   
16463   
16464   
16465  ############################### 
16466  # forms.h (xpopup.h) 
16467  # Prototypes for xpop-up menus 
16468  ############################### 
16469   
16470 -def fl_setpup_entries(popupid, pPopupEntry): 
16471      """ 
16472          fl_setpup_entries(popupid, pPopupEntry) -> num. 
16473      """ 
16474   
16475      _fl_setpup_entries = cfuncproto( 
16476              load_so_libforms(), "fl_setpup_entries", 
16477              cty.c_int, [cty.c_int, cty.POINTER(FL_PUP_ENTRY)], 
16478              """int fl_setpup_entries(int nm, FL_PUP_ENTRY * entries) 
16479              """) 
16480      ipopupid = convert_to_int(popupid) 
16481      keep_elem_refs(popupid, pPopupEntry, ipopupid) 
16482      retval = _fl_setpup_entries(ipopupid, pPopupEntry) 
16483      return retval 
16484   
16485   
16486 -def fl_newpup(win): 
16487      """ 
16488          fl_newpup(win) -> num. 
16489      """ 
16490   
16491      _fl_newpup = cfuncproto( 
16492              load_so_libforms(), "fl_newpup", 
16493              cty.c_int, [Window], 
16494              """int fl_newpup(Window win) 
16495              """) 
16496      ulwin = convert_to_Window(win) 
16497      keep_elem_refs(win, ulwin) 
16498      retval = _fl_newpup(ulwin) 
16499      return retval 
16500   
16501   
16502 -def fl_defpup(win, pupstr): 
16503      """ 
16504          fl_defpup(win, pupstr) -> num. 
16505      """ 
16506   
16507      _fl_defpup = cfuncproto( 
16508              load_so_libforms(), "fl_defpup", 
16509              cty.c_int, [Window, STRING], 
16510              """int fl_defpup(Window win, const char * str): 
16511              """) 
16512      ulwin = convert_to_Window(win) 
16513      spupstr = convert_to_string(pupstr) 
16514      keep_elem_refs(win, pupstr, ulwin, spupstr) 
16515      retval = _fl_defpup(ulwin, spupstr) 
16516      return retval 
16517   
16518   
16519 -def fl_addtopup(popupid, pupstr): 
16520      """ 
16521          fl_addtopup(popupid, pupstr) -> num. 
16522      """ 
16523   
16524      _fl_addtopup = cfuncproto( 
16525              load_so_libforms(), "fl_addtopup", 
16526              cty.c_int, [cty.c_int, STRING], 
16527              """int fl_addtopup(int n, const char * str) 
16528              """) 
16529      ipopupid = convert_to_int(popupid) 
16530      spupstr = convert_to_string(pupstr) 
16531      keep_elem_refs(popupid, pupstr, ipopupid, spupstr) 
16532      retval = _fl_addtopup(ipopupid, spupstr) 
16533      return retval 
16534   
16535   
16536 -def fl_setpup_mode(popupid, itemval, mode): 
16537      """ 
16538          fl_setpup_mode(popupid, itemval, mode) -> num. 
16539      """ 
16540   
16541      _fl_setpup_mode = cfuncproto( 
16542              load_so_libforms(), "fl_setpup_mode", 
16543              cty.c_int, [cty.c_int, cty.c_int, cty.c_uint], 
16544              """int fl_setpup_mode(int nm, int ni, unsigned int mode) 
16545              """) 
16546      ipopupid = convert_to_int(popupid) 
16547      iitemval = convert_to_int(itemval) 
16548      uimode = convert_to_uint(mode) 
16549      keep_elem_refs(popupid, itemval, mode, ipopupid, iitemval, uimode) 
16550      retval = _fl_setpup_mode(ipopupid, iitemval, uimode) 
16551      return retval 
16552   
16553   
16554 -def fl_freepup(popupid): 
16555      """ 
16556          fl_freepup(popupid) 
16557      """ 
16558   
16559      _fl_freepup = cfuncproto( 
16560              load_so_libforms(), "fl_freepup", 
16561              None, [cty.c_int], 
16562              """void fl_freepup(int n) 
16563              """) 
16564      ipopupid = convert_to_int(popupid) 
16565      keep_elem_refs(popupid, ipopupid) 
16566      _fl_freepup(ipopupid) 
16567   
16568   
16569 -def fl_dopup(popupid): 
16570      """ 
16571          fl_dopup(popupid) -> num. 
16572      """ 
16573   
16574      _fl_dopup = cfuncproto( 
16575              load_so_libforms(), "fl_dopup", 
16576              cty.c_int, [cty.c_int], 
16577              """int fl_dopup(int n) 
16578              """) 
16579      ipopupid = convert_to_int(popupid) 
16580      keep_elem_refs(popupid, ipopupid) 
16581      retval = _fl_dopup(ipopupid) 
16582      return retval 
16583   
16584   
16585 -def fl_setpup_default_cursor(cursor): 
16586      """ 
16587          fl_setpup_default_cursor(cursor) -> cursor 
16588      """ 
16589   
16590      _fl_setpup_default_cursor = cfuncproto( 
16591              load_so_libforms(), "fl_setpup_default_cursor", 
16592              Cursor, [cty.c_int], 
16593              """Cursor fl_setpup_default_cursor(int cursor): 
16594              """) 
16595      icursor = convert_to_int(cursor) 
16596      keep_elem_refs(cursor, icursor) 
16597      retval = _fl_setpup_default_cursor(icursor) 
16598      return retval 
16599   
16600   
16601 -def fl_setpup_default_color(fgcolr, bgcolr): 
16602      """ 
16603          fl_setpup_default_color(fgcolr, bgcolr) 
16604      """ 
16605   
16606      _fl_setpup_default_color = cfuncproto( 
16607              load_so_libforms(), "fl_setpup_default_color", 
16608              None, [FL_COLOR, FL_COLOR], 
16609              """void fl_setpup_default_color(FL_COLOR fg, FL_COLOR bg) 
16610              """) 
16611      ulfgcolr = convert_to_FL_COLOR(fgcolr) 
16612      ulbgcolr = convert_to_FL_COLOR(bgcolr) 
16613      keep_elem_refs(fgcolr, bgcolr, ulfgcolr, ulbgcolr) 
16614      _fl_setpup_default_color(ulfgcolr, ulbgcolr) 
16615   
16616   
16617 -def fl_setpup_default_pup_checked_color(colr): 
16618      """ 
16619          fl_setpup_default_pup_checked_color(colr): 
16620      """ 
16621   
16622      _fl_setpup_default_pup_checked_color = cfuncproto( 
16623              load_so_libforms(), "fl_setpup_default_pup_checked_color", 
16624              None, [FL_COLOR], 
16625              """void fl_setpup_default_pup_checked_color(FL_COLOR col) 
16626              """) 
16627      ulcolr = convert_to_FL_COLOR(colr) 
16628      keep_elem_refs(colr, ulcolr) 
16629      _fl_setpup_default_pup_checked_color(ulcolr) 
16630   
16631   
16632 -def fl_setpup_default_fontsize(size): 
16633      """ 
16634          fl_setpup_default_fontsize(size) -> num. 
16635      """ 
16636   
16637      _fl_setpup_default_fontsize = cfuncproto( 
16638              load_so_libforms(), "fl_setpup_default_fontsize", 
16639              cty.c_int, [cty.c_int], 
16640              """int fl_setpup_default_fontsize(int size)    DEPRECATED? 
16641              """) 
16642      isize = convert_to_int(size) 
16643      keep_elem_refs(size, isize) 
16644      retval = _fl_setpup_default_fontsize(isize) 
16645      return retval 
16646   
16647   
16648 -def fl_setpup_default_fontstyle(style): 
16649      """ 
16650          fl_setpup_default_fontstyle(style) -> num. 
16651      """ 
16652   
16653      _fl_setpup_default_fontstyle = cfuncproto( 
16654              load_so_libforms(), "fl_setpup_default_fontstyle", 
16655              cty.c_int, [cty.c_int], 
16656              """int fl_setpup_default_fontstyle(int style) 
16657              """) 
16658      istyle = convert_to_int(style) 
16659      keep_elem_refs(style, istyle) 
16660      retval = _fl_setpup_default_fontstyle(istyle) 
16661      return retval 
16662   
16663   
16664  fl_setpup_fontsize = fl_setpup_default_fontsize 
16665  fl_setpup_fontstyle = fl_setpup_default_fontstyle 
16666  fl_setpup_color = fl_setpup_default_color 
16667  fl_setpup_default_checkcolor = fl_setpup_default_pup_checked_color 
16668  fl_setpup_checkcolor = fl_setpup_default_pup_checked_color 
16669   
16670   
16671 -def fl_setpup_default_bw(bw): 
16672      """ 
16673          fl_setpup_default_bw(bw) -> num. 
16674      """ 
16675   
16676      _fl_setpup_default_bw = cfuncproto( 
16677              load_so_libforms(), "fl_setpup_default_bw", 
16678              cty.c_int, [cty.c_int], 
16679              """int fl_setpup_default_bw(int bw): 
16680              """) 
16681      ibw = convert_to_int(bw) 
16682      keep_elem_refs(bw, ibw) 
16683      retval = _fl_setpup_default_bw(ibw) 
16684      return retval 
16685   
16686   
16687 -def fl_setpup_shortcut(popupid, itemval, hotkeystxt): 
16688      """ 
16689          fl_setpup_shortcut(popupid, itemval, hotkeystxt) 
16690      """ 
16691   
16692      _fl_setpup_shortcut = cfuncproto( 
16693              load_so_libforms(), "fl_setpup_shortcut", 
16694              None, [cty.c_int, cty.c_int, STRING], 
16695              """void fl_setpup_shortcut(int nm, int ni, const char * sc) 
16696              """) 
16697      ipopupid = convert_to_int(popupid) 
16698      iitemval = convert_to_int(itemval) 
16699      shotkeystxt = convert_to_string(hotkeystxt) 
16700      keep_elem_refs(popupid, itemval, hotkeystxt, ipopupid, iitemval, \ 
16701                     shotkeystxt) 
16702      _fl_setpup_shortcut(ipopupid, iitemval, shotkeystxt) 
16703   
16704   
16705 -def fl_setpup_position(x, y): 
16706      """ 
16707          fl_setpup_position(x, y) 
16708      """ 
16709   
16710      _fl_setpup_position = cfuncproto( 
16711              load_so_libforms(), "fl_setpup_position", 
16712              None, [cty.c_int, cty.c_int], 
16713              """void fl_setpup_position(int x, int y) 
16714              """) 
16715      ix = convert_to_int(x) 
16716      iy = convert_to_int(y) 
16717      keep_elem_refs(x, y, ix, iy) 
16718      _fl_setpup_position(ix, iy) 
16719   
16720   
16721 -def fl_setpup_selection(popupid, itemval): 
16722      """ 
16723          fl_setpup_selection(popupid, itemval) 
16724      """ 
16725   
16726      _fl_setpup_selection = cfuncproto( 
16727              load_so_libforms(), "fl_setpup_selection", 
16728              None, [cty.c_int, cty.c_int], 
16729              """void fl_setpup_selection(int nm, int ni) 
16730              """) 
16731      ipopupid = convert_to_int(popupid) 
16732      iitemval = convert_to_int(itemval) 
16733      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16734      _fl_setpup_selection(ipopupid, iitemval) 
16735   
16736   
16737 -def fl_setpup_shadow(popupid, flag): 
16738      """ 
16739          fl_setpup_shadow(popupid, flag) 
16740      """ 
16741   
16742      _fl_setpup_shadow = cfuncproto( 
16743              load_so_libforms(), "fl_setpup_shadow", 
16744              None, [cty.c_int, cty.c_int], 
16745              """void fl_setpup_shadow(int n, int y) 
16746              """) 
16747      ipopupid = convert_to_int(popupid) 
16748      iflag = convert_to_int(flag) 
16749      keep_elem_refs(popupid, flag, ipopupid, iflag) 
16750      _fl_setpup_shadow(ipopupid, iflag) 
16751   
16752   
16753 -def fl_setpup_softedge(popupid, flag): 
16754      """ 
16755          fl_setpup_softedge(popupid, flag) 
16756      """ 
16757   
16758      _fl_setpup_softedge = cfuncproto( 
16759              load_so_libforms(), "fl_setpup_softedge", 
16760              None, [cty.c_int, cty.c_int], 
16761              """void fl_setpup_softedge(int n, int y) 
16762              """) 
16763      ipopupid = convert_to_int(popupid) 
16764      iflag = convert_to_int(flag) 
16765      keep_elem_refs(popupid, flag, ipopupid, iflag) 
16766      _fl_setpup_softedge(ipopupid, iflag) 
16767   
16768   
16769 -def fl_setpup_bw(popupid, bw): 
16770      """ 
16771          fl_setpup_bw(popupid, bw) 
16772      """ 
16773   
16774      _fl_setpup_bw = cfuncproto( 
16775              load_so_libforms(), "fl_setpup_bw", 
16776              None, [cty.c_int, cty.c_int], 
16777              """void fl_setpup_bw(int n, int bw) 
16778              """) 
16779      ipopupid = convert_to_int(popupid) 
16780      ibw = convert_to_int(bw) 
16781      keep_elem_refs(popupid, bw, ipopupid, ibw) 
16782      _fl_setpup_bw(ipopupid, ibw) 
16783   
16784   
16785 -def fl_setpup_title(popupid, title): 
16786      """ 
16787          fl_setpup_title(popupid, title) 
16788      """ 
16789   
16790      _fl_setpup_title = cfuncproto( 
16791              load_so_libforms(), "fl_setpup_title", 
16792              None, [cty.c_int, STRING], 
16793              """void fl_setpup_title(int nm, const char * title) 
16794              """) 
16795      ipopupid = convert_to_int(popupid) 
16796      stitle = convert_to_string(title) 
16797      keep_elem_refs(popupid, title, ipopupid, stitle) 
16798      _fl_setpup_title(ipopupid, stitle) 
16799   
16800   
16801  FL_PUP_ENTERCB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
16802   
16803 -def fl_setpup_entercb(popupid, py_PupEnterCb, data): 
16804      """ 
16805          fl_setpup_entercb(popupid, py_PupEnterCb, data) -> pup_entercb 
16806      """ 
16807   
16808      _fl_setpup_entercb = cfuncproto( 
16809              load_so_libforms(), "fl_setpup_entercb", 
16810              FL_PUP_ENTERCB, [cty.c_int, FL_PUP_ENTERCB, cty.c_void_p], 
16811              """FL_PUP_ENTERCB fl_setpup_entercb(int nm, FL_PUP_ENTERCB cb, 
16812                 void * data) 
16813              """) 
16814      ipopupid = convert_to_int(popupid) 
16815      c_PupEnterCb = FL_PUP_ENTERCB(py_PupEnterCb) 
16816      pdata = cty.cast(data, cty.c_void_p) 
16817      keep_cfunc_refs(c_PupEnterCb, py_PupEnterCb) 
16818      keep_elem_refs(popupid, data, ipopupid, pdata) 
16819      retval = _fl_setpup_entercb(ipopupid, c_PupEnterCb, pdata) 
16820      return retval 
16821   
16822   
16823  FL_PUP_LEAVECB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 
16824   
16825 -def fl_setpup_leavecb(popupid, py_LeaveCb, data): 
16826      """ 
16827          fl_setpup_leavecb(popupid, py_LeaveCb, data) -> pup_leavecb 
16828      """ 
16829   
16830      _fl_setpup_leavecb = cfuncproto( 
16831              load_so_libforms(), "fl_setpup_leavecb", 
16832              FL_PUP_LEAVECB, [cty.c_int, FL_PUP_LEAVECB, cty.c_void_p], 
16833              """FL_PUP_LEAVECB fl_setpup_leavecb(int nm, FL_PUP_LEAVECB cb, 
16834                 void * data) 
16835              """) 
16836      ipopupid = convert_to_int(popupid) 
16837      c_LeaveCb = FL_PUP_LEAVECB(py_LeaveCb) 
16838      pdata = cty.cast(data, cty.c_void_p) 
16839      keep_cfunc_refs(c_LeaveCb, py_LeaveCb) 
16840      keep_elem_refs(popupid, data, ipopupid, pdata) 
16841      retval = _fl_setpup_leavecb(ipopupid, c_LeaveCb, pdata) 
16842      return retval 
16843   
16844   
16845 -def fl_setpup_pad(popupid, padw, padh): 
16846      """ 
16847          fl_setpup_pad(popupid, padw, padh) 
16848      """ 
16849   
16850      _fl_setpup_pad = cfuncproto( 
16851              load_so_libforms(), "fl_setpup_pad", 
16852              None, [cty.c_int, cty.c_int, cty.c_int], 
16853              """void fl_setpup_pad(int n, int padw, int padh) 
16854              """) 
16855      ipopupid = convert_to_int(popupid) 
16856      ipadw = convert_to_int(padw) 
16857      ipadh = convert_to_int(padh) 
16858      keep_elem_refs(popupid, padw, padh, ipopupid, ipadw, ipadh) 
16859      _fl_setpup_pad(ipopupid, ipadw, ipadh) 
16860   
16861   
16862 -def fl_setpup_cursor(popupid, cursor): 
16863      """ 
16864          fl_setpup_cursor(popupid, cursor) -> cursor 
16865      """ 
16866   
16867      _fl_setpup_cursor = cfuncproto( 
16868              load_so_libforms(), "fl_setpup_cursor", 
16869              Cursor, [cty.c_int, cty.c_int], 
16870              """Cursor fl_setpup_cursor(int nm, int cursor) 
16871              """) 
16872      ipopupid = convert_to_int(popupid) 
16873      icursor = convert_to_int(cursor) 
16874      keep_elem_refs(popupid, cursor, ipopupid, icursor) 
16875      retval = _fl_setpup_cursor(ipopupid, icursor) 
16876      return retval 
16877   
16878   
16879 -def fl_setpup_maxpup(newmaxnum): 
16880      """ 
16881          fl_setpup_maxpup(newmaxnum) -> num. 
16882      """ 
16883   
16884      _fl_setpup_maxpup = cfuncproto( 
16885              load_so_libforms(), "fl_setpup_maxpup", 
16886              cty.c_int, [cty.c_int], 
16887              """int fl_setpup_maxpup(int n) 
16888              """) 
16889      inewmaxnum = convert_to_int(newmaxnum) 
16890      keep_elem_refs(newmaxnum, inewmaxnum) 
16891      retval = _fl_setpup_maxpup(inewmaxnum) 
16892      return retval 
16893   
16894   
16895 -def fl_getpup_mode(popupid, itemval): 
16896      """ 
16897          fl_getpup_mode(popupid, itemval) -> num. 
16898      """ 
16899   
16900      _fl_getpup_mode = cfuncproto( 
16901              load_so_libforms(), "fl_getpup_mode", 
16902              cty.c_uint, [cty.c_int, cty.c_int], 
16903              """unsigned int fl_getpup_mode(int nm, int ni) 
16904              """) 
16905      ipopupid = convert_to_int(popupid) 
16906      iitemval = convert_to_int(itemval) 
16907      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16908      retval = _fl_getpup_mode(ipopupid, iitemval) 
16909      return retval 
16910   
16911   
16912 -def fl_getpup_text(popupid, itemval): 
16913      """ 
16914          fl_getpup_text(popupid, itemval) -> text string 
16915      """ 
16916   
16917      _fl_getpup_text = cfuncproto( 
16918              load_so_libforms(), "fl_getpup_text", 
16919              STRING, [cty.c_int, cty.c_int], 
16920              """const char * fl_getpup_text(int nm, int ni) 
16921              """) 
16922      ipopupid = convert_to_int(popupid) 
16923      iitemval = convert_to_int(itemval) 
16924      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
16925      retval = _fl_getpup_text(ipopupid, iitemval) 
16926      return retval 
16927   
16928   
16929 -def fl_showpup(popupid): 
16930      """ 
16931          fl_showpup(popupid) 
16932      """ 
16933   
16934      _fl_showpup = cfuncproto( 
16935              load_so_libforms(), "fl_showpup", 
16936              None, [cty.c_int], 
16937              """void fl_showpup(int n) 
16938              """) 
16939      ipopupid = convert_to_int(popupid) 
16940      keep_elem_refs(popupid, ipopupid) 
16941      _fl_showpup(ipopupid) 
16942   
16943   
16944 -def fl_hidepup(popupid): 
16945      """ 
16946          fl_hidepup(popupid) 
16947      """ 
16948   
16949      _fl_hidepup = cfuncproto( 
16950              load_so_libforms(), "fl_hidepup", 
16951              None, [cty.c_int], 
16952              """void fl_hidepup(int n) 
16953              """) 
16954      ipopupid = convert_to_int(popupid) 
16955      keep_elem_refs(popupid, ipopupid) 
16956      _fl_hidepup(ipopupid) 
16957   
16958   
16959 -def fl_getpup_items(popupid): 
16960      """ 
16961          fl_getpup_items(popupid) -> num. 
16962      """ 
16963   
16964      _fl_getpup_items = cfuncproto( 
16965              load_so_libforms(), "fl_getpup_items", 
16966              cty.c_int, [cty.c_int], 
16967              """int fl_getpup_items(int n) 
16968              """) 
16969      ipopupid = convert_to_int(popupid) 
16970      keep_elem_refs(popupid, ipopupid) 
16971      retval = _fl_getpup_items(ipopupid) 
16972      return retval 
16973   
16974   
16975 -def fl_current_pup(): 
16976      """ 
16977          fl_current_pup() -> num. 
16978      """ 
16979   
16980      _fl_current_pup = cfuncproto( 
16981              load_so_libforms(), "fl_current_pup", 
16982              cty.c_int, [], 
16983              """int fl_current_pup() 
16984              """) 
16985      retval = _fl_current_pup() 
16986      return retval 
16987   
16988   
16989 -def fl_setpup_itemcb(popupid, itemval, py_PupCb): 
16990      """ 
16991          fl_setpup_itemcb(popupid, itemval, py_PupCb) -> pup_cb 
16992      """ 
16993   
16994      _fl_setpup_itemcb = cfuncproto( 
16995              load_so_libforms(), "fl_setpup_itemcb", 
16996              FL_PUP_CB, [cty.c_int, cty.c_int, FL_PUP_CB], 
16997              """FL_PUP_CB fl_setpup_itemcb(int nm, int ni, FL_PUP_CB cb) 
16998              """) 
16999      ipopupid = convert_to_int(popupid) 
17000      iitemval = convert_to_int(itemval) 
17001      c_PupCb = FL_PUP_CB(py_PupCb) 
17002      keep_cfunc_refs(c_PupCb, py_PupCb) 
17003      keep_elem_refs(popupid, itemval, ipopupid, iitemval) 
17004      retval = _fl_setpup_itemcb(ipopupid, iitemval, c_PupCb) 
17005      return retval 
17006   
17007   
17008 -def fl_setpup_menucb(popupid, py_PupCb): 
17009      """ fl_setpup_menucb(popupid, py_PupCb) -> pup_cb func. 
17010      """ 
17011   
17012      _fl_setpup_menucb = cfuncproto( 
17013              load_so_libforms(), "fl_setpup_menucb", 
17014              FL_PUP_CB, [cty.c_int, FL_PUP_CB], 
17015              """FL_PUP_CB fl_setpup_menucb(int nm, FL_PUP_CB cb) 
17016              """) 
17017      ipopupid = convert_to_int(popupid) 
17018      c_PupCb = FL_PUP_CB(py_PupCb) 
17019      keep_cfunc_refs(c_PupCb, py_PupCb) 
17020      keep_elem_refs(popupid, ipopupid) 
17021      retval = _fl_setpup_menucb(ipopupid, c_PupCb) 
17022      return retval 
17023   
17024   
17025 -def fl_setpup_submenu(popupid, itemval, subpopupid): 
17026      """ 
17027          fl_setpup_submenu(popupid, itemval, subpopupid) 
17028      """ 
17029   
17030      _fl_setpup_submenu = cfuncproto( 
17031              load_so_libforms(), "fl_setpup_submenu", 
17032              None, [cty.c_int, cty.c_int, cty.c_int], 
17033              """void fl_setpup_submenu(int m, int i, int subm) 
17034              """) 
17035      ipopupid = convert_to_int(popupid) 
17036      iitemval = convert_to_int(itemval) 
17037      isubpopupid = convert_to_int(subpopupid) 
17038      keep_elem_refs(popupid, itemval, subpopupid, ipopupid, iitemval, \ 
17039                     isubpopupid) 
17040      _fl_setpup_submenu(ipopupid, iitemval, isubpopupid) 
17041   
17042   
17043  fl_setpup = fl_setpup_mode 
17044   
17045   
17046  # Others 
17047   
17048 -def fl_create_xyplot(plottype, x, y, w, h, label): 
17049      """ 
17050          fl_create_xyplot(plottype, x, y, w, h, label) -> pObject 
17051      """ 
17052   
17053      _fl_create_xyplot = cfuncproto( 
17054              load_so_libforms(), "fl_create_xyplot", 
17055              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
17056              FL_Coord, STRING], 
17057              """FL_OBJECT * fl_create_xyplot(int t, FL_Coord x, FL_Coord y, 
17058                 FL_Coord w, FL_Coord h, const char * label) 
17059              """) 
17060      check_admitted_listvalues(plottype, XYPLOTTYPE_list) 
17061      iplottype = convert_to_int(plottype) 
17062      ix = convert_to_FL_Coord(x) 
17063      iy = convert_to_FL_Coord(y) 
17064      iw = convert_to_FL_Coord(w) 
17065      ih = convert_to_FL_Coord(h) 
17066      slabel = convert_to_string(label) 
17067      keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 
17068                     iw, ih, slabel) 
17069      retval = _fl_create_xyplot(iplottype, ix, iy, iw, ih, slabel) 
17070      return retval 
17071   
17072   
17073 -def fl_add_xyplot(plottype, x, y, w, h, label): 
17074      """ 
17075          fl_add_xyplot(plottype, x, y, w, h, label) -> pObject 
17076      """ 
17077   
17078      _fl_add_xyplot = cfuncproto( 
17079              load_so_libforms(), "fl_add_xyplot", 
17080              cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 
17081              FL_Coord, STRING], 
17082              """FL_OBJECT * fl_add_xyplot(int t, FL_Coord x, FL_Coord y, 
17083                 FL_Coord w, FL_Coord h, const char * label) 
17084              """) 
17085      check_admitted_listvalues(plottype, XYPLOTTYPE_list) 
17086      iplottype = convert_to_int(plottype) 
17087      ix = convert_to_FL_Coord(x) 
17088      iy = convert_to_FL_Coord(y) 
17089      iw = convert_to_FL_Coord(w) 
17090      ih = convert_to_FL_Coord(h) 
17091      slabel = convert_to_string(label) 
17092      keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 
17093                     iw, ih, slabel) 
17094      retval = _fl_add_xyplot(iplottype, ix, iy, iw, ih, slabel) 
17095      return retval 
17096   
17097   
17098 -def fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel): 
17099      """ 
17100           fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel) 
17101   
17102          @param pObject : pointer to object 
17103      """ 
17104   
17105      _fl_set_xyplot_data = cfuncproto( 
17106              load_so_libforms(), "fl_set_xyplot_data", 
17107              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17108              cty.POINTER(cty.c_float), cty.c_int, STRING, STRING, STRING], 
17109              """void fl_set_xyplot_data(FL_OBJECT * ob, float * x, float * y, 
17110                 int n, const char * title, const char * xlabel, 
17111                 const char * ylabel) 
17112              """) 
17113      #px = cty.cast(x, cty.POINTER(cty.c_float)) 
17114      print xlist, xlist[0] 
17115      fx = [] 
17116      for a in range(xlist): 
17117          fx[a] = convert_to_float(xlist[a]) 
17118      px = cty.pointer(fx) 
17119      print "x, fx, px", xlist, fx, px 
17120      #py = cty.cast(y, cty.POINTER(cty.c_float)) 
17121      fy = [] 
17122      for a in range(ylist): 
17123          fy[a] = convert_to_float(ylist[a]) 
17124      py = cty.pointer(fy) 
17125      print "y, fy, py", ylist, fy, py 
17126      inum = convert_to_int(n) 
17127      stitle = convert_to_string(title) 
17128      sxlabel = convert_to_string(xlabel) 
17129      sylabel = convert_to_string(ylabel) 
17130      keep_elem_refs(pObject, xlist, ylist, n, fx, fy, px, py, title, \ 
17131                     xlabel, ylabel, inum, stitle, sxlabel, sylabel) 
17132      _fl_set_xyplot_data(pObject, px, py, inum, stitle, sxlabel, sylabel) 
17133   
17134   
17135 -def fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel): 
17136      """ fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel) 
17137   
17138          @param pObject : pointer to object 
17139      """ 
17140   
17141      _fl_set_xyplot_data_double = cfuncproto( 
17142              load_so_libforms(), "fl_set_xyplot_data_double", 
17143              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 
17144              cty.POINTER(cty.c_double), cty.c_int, STRING, STRING, STRING], 
17145              """void fl_set_xyplot_data_double(FL_OBJECT * ob, double * x, 
17146                 double * y, int n, const char * title, const char * xlabel, 
17147                 const char * ylabel) 
17148              """) 
17149      px = cty.cast(x, cty.POINTER(cty.c_double)) 
17150      py = cty.cast(y, cty.POINTER(cty.c_double)) 
17151      inum = convert_to_int(n) 
17152      stitle = convert_to_string(title) 
17153      sxlabel = convert_to_string(xlabel) 
17154      sylabel = convert_to_string(ylabel) 
17155      keep_elem_refs(pObject, x, y, n, title, xlabel, ylabel, px, py, inum, \ 
17156                     stitle, sxlabel, sylabel) 
17157      _fl_set_xyplot_data_double(pObject, px, py, n, title, \ 
17158                                          xlabel, ylabel, inum, stitle, \ 
17159                                          sxlabel, sylabel) 
17160   
17161   
17162 -def fl_set_xyplot_file(pObject, f, title, xl, yl): 
17163      """ fl_set_xyplot_file(pObject, f, title, xl, yl) -> num. 
17164   
17165          @param pObject : pointer to object 
17166      """ 
17167   
17168      _fl_set_xyplot_file = cfuncproto( 
17169              load_so_libforms(), "fl_set_xyplot_file", 
17170              cty.c_int, [cty.POINTER(FL_OBJECT), STRING, STRING, STRING, 
17171              STRING], 
17172              """int fl_set_xyplot_file(FL_OBJECT * ob, const char * f, 
17173                 const char * title, const char * xl, const char * yl) 
17174              """) 
17175      sf = convert_to_string(f) 
17176      stitle = convert_to_string(title) 
17177      sxl = convert_to_string(xl) 
17178      syl = convert_to_string(yl) 
17179      keep_elem_refs(pObject, f, title, xl, yl, sf, stitle, sxl, syl) 
17180      retval = _fl_set_xyplot_file(pObject, sf, stitle, sxl, syl) 
17181      return retval 
17182   
17183   
17184 -def fl_insert_xyplot_data(pObject, idnum, n, valx, valy): 
17185      """  
17186          fl_insert_xyplot_data(pObject, idnum, n, valx, valy) 
17187   
17188          @param pObject : pointer to object 
17189      """ 
17190   
17191      _fl_insert_xyplot_data = cfuncproto( 
17192              load_so_libforms(), "fl_insert_xyplot_data", 
17193              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_double, 
17194              cty.c_double], 
17195              """void fl_insert_xyplot_data(FL_OBJECT * ob, int id, int n, 
17196                 double x, double y) 
17197              """) 
17198      iidnum = convert_to_int(idnum) 
17199      inum = convert_to_int(n) 
17200      fvalx = convert_to_double(valx) 
17201      fvaly = convert_to_double(valy) 
17202      keep_elem_refs(pObject, idnum, n, valx, valy, iidnum, inum, fvalx, fvaly) 
17203      _fl_insert_xyplot_data(pObject, iidnum, inum, fvalx, fvaly) 
17204   
17205   
17206 -def fl_add_xyplot_text(pObject, valx, valy, text, al, colr): 
17207      """ 
17208          fl_add_xyplot_text(pObject, valx, valy, text, al, colr) 
17209   
17210          @param pObject : pointer to object 
17211      """ 
17212   
17213      _fl_add_xyplot_text = cfuncproto( 
17214              load_so_libforms(), "fl_add_xyplot_text", 
17215              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, STRING, 
17216              cty.c_int, FL_COLOR], 
17217              """void fl_add_xyplot_text(FL_OBJECT * ob, double x, double y, 
17218                 const char * text, int al, FL_COLOR col) 
17219              """) 
17220      fvalx = convert_to_double(valx) 
17221      fvaly = convert_to_double(valy) 
17222      stext = convert_to_string(text) 
17223      ial = convert_to_int(al) 
17224      ulcolr = convert_to_FL_COLOR(colr) 
17225      keep_elem_refs(pObject, valx, valy, text, al, colr, fvalx, fvaly, \ 
17226                     stext, ial, ulcolr) 
17227      _fl_add_xyplot_text(pObject, fvalx, fvaly, stext, ial, ulcolr) 
17228   
17229   
17230 -def fl_delete_xyplot_text(pObject, text): 
17231      """ 
17232          fl_delete_xyplot_text(pObject, text) 
17233   
17234          @param pObject : pointer to object 
17235      """ 
17236   
17237      _fl_delete_xyplot_text = cfuncproto( 
17238              load_so_libforms(), "fl_delete_xyplot_text", 
17239              None, [cty.POINTER(FL_OBJECT), STRING], 
17240              """void fl_delete_xyplot_text(FL_OBJECT * ob, const char * text) 
17241              """) 
17242      stext = convert_to_string(text) 
17243      keep_elem_refs(pObject, text, stext) 
17244      _fl_delete_xyplot_text(pObject, stext) 
17245   
17246   
17247 -def fl_set_xyplot_maxoverlays(pObject, maxover): 
17248      """ 
17249          fl_set_xyplot_maxoverlays(pObject, maxover) -> num. 
17250   
17251          @param pObject : pointer to object 
17252      """ 
17253   
17254      _fl_set_xyplot_maxoverlays = cfuncproto( 
17255              load_so_libforms(), "fl_set_xyplot_maxoverlays", 
17256              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
17257              """int fl_set_xyplot_maxoverlays(FL_OBJECT * ob, int maxover) 
17258              """) 
17259      imaxover = convert_to_int(maxover) 
17260      keep_elem_refs(pObject, maxover, imaxover) 
17261      retval = _fl_set_xyplot_maxoverlays(pObject, imaxover) 
17262      return retval 
17263   
17264   
17265 -def fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr): 
17266      """ 
17267          fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr) 
17268   
17269          @param pObject : pointer to object 
17270      """ 
17271   
17272      _fl_add_xyplot_overlay = cfuncproto( 
17273              load_so_libforms(), "fl_add_xyplot_overlay", 
17274              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 
17275              cty.POINTER(cty.c_float), cty.c_int, FL_COLOR], 
17276              """void fl_add_xyplot_overlay(FL_OBJECT * ob, int id, float * x, 
17277                 float * y, int n, FL_COLOR col) 
17278              """) 
17279      iidnum = convert_to_int(idnum) 
17280      px = cty.cast(x, cty.POINTER(cty.c_float)) 
17281      py = cty.cast(y, cty.POINTER(cty.c_float)) 
17282      inum = convert_to_int(n) 
17283      ulcolr = convert_to_FL_COLOR(colr) 
17284      keep_elem_refs(pObject, idnum, x, y, n, colr, iidnum, px, py, inum, \ 
17285                     ulcolr) 
17286      _fl_add_xyplot_overlay(pObject, iidnum, px, py, inum, ulcolr) 
17287   
17288   
17289 -def fl_add_xyplot_overlay_file(pObject, idnum, f, colr): 
17290      """ 
17291          fl_add_xyplot_overlay_file(pObject, idnum, f, colr) -> num. 
17292   
17293          @param pObject : pointer to object 
17294      """ 
17295   
17296      _fl_add_xyplot_overlay_file = cfuncproto( 
17297              load_so_libforms(), "fl_add_xyplot_overlay_file", 
17298              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, STRING, FL_COLOR], 
17299              """int fl_add_xyplot_overlay_file(FL_OBJECT * ob, int id, 
17300              const char * f, FL_COLOR c) 
17301              """) 
17302      iidnum = convert_to_int(idnum) 
17303      sf = convert_to_string(f) 
17304      ulcolr = convert_to_FL_COLOR(colr) 
17305      keep_elem_refs(pObject, idnum, f, colr, iidnum, sf, ulcolr) 
17306      retval = _fl_add_xyplot_overlay_file(pObject, iidnum, sf, ulcolr) 
17307      return retval 
17308   
17309   
17310 -def fl_set_xyplot_return(pObject, when): 
17311      """ 
17312          fl_set_xyplot_return(pObject, when) 
17313   
17314          @param pObject : pointer to object 
17315      """ 
17316   
17317      _fl_set_xyplot_return = cfuncproto( 
17318              load_so_libforms(), "fl_set_xyplot_return", 
17319              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17320              """void fl_set_xyplot_return(FL_OBJECT * ob, int when) 
17321              """) 
17322      iwhen = convert_to_int(when) 
17323      keep_elem_refs(pObject, when, iwhen) 
17324      _fl_set_xyplot_return(pObject, iwhen) 
17325   
17326   
17327 -def fl_set_xyplot_xtics(pObject, major, minor): 
17328      """ 
17329          fl_set_xyplot_xtics(pObject, major, minor) 
17330   
17331          @param pObject : pointer to object 
17332      """ 
17333   
17334      _fl_set_xyplot_xtics = cfuncproto( 
17335              load_so_libforms(), "fl_set_xyplot_xtics", 
17336              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17337              """void fl_set_xyplot_xtics(FL_OBJECT * ob, int major, int minor) 
17338              """) 
17339      imajor = convert_to_int(major) 
17340      iminor = convert_to_int(minor) 
17341      keep_elem_refs(pObject, major, minor, imajor, iminor) 
17342      _fl_set_xyplot_xtics(pObject, imajor, iminor) 
17343   
17344   
17345 -def fl_set_xyplot_ytics(pObject, major, minor): 
17346      """ 
17347          fl_set_xyplot_ytics(pObject, major, minor) 
17348   
17349          @param pObject : pointer to object 
17350      """ 
17351   
17352      _fl_set_xyplot_ytics = cfuncproto( 
17353              load_so_libforms(), "fl_set_xyplot_ytics", 
17354              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17355              """void fl_set_xyplot_ytics(FL_OBJECT * ob, int major, int minor) 
17356              """) 
17357      imajor = convert_to_int(major) 
17358      iminor = convert_to_int(minor) 
17359      keep_elem_refs(pObject, major, minor, imajor, iminor) 
17360      _fl_set_xyplot_ytics(pObject, imajor, iminor) 
17361   
17362   
17363 -def fl_set_xyplot_xbounds(pObject, minbound, maxbound): 
17364      """ 
17365          fl_set_xyplot_xbounds(pObject, minbound, maxbound) 
17366   
17367          @param pObject : pointer to object 
17368      """ 
17369   
17370      _fl_set_xyplot_xbounds = cfuncproto( 
17371              load_so_libforms(), "fl_set_xyplot_xbounds", 
17372              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
17373              """void fl_set_xyplot_xbounds(FL_OBJECT * ob, double xmin, 
17374                 double xmax) 
17375              """) 
17376      fminbound = convert_to_double(minbound) 
17377      fmaxbound = convert_to_double(maxbound) 
17378      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
17379      _fl_set_xyplot_xbounds(pObject, fminbound, fmaxbound) 
17380   
17381   
17382 -def fl_set_xyplot_ybounds(pObject, minbound, maxbound): 
17383      """ 
17384          fl_set_xyplot_ybounds(pObject, minbound, maxbound) 
17385   
17386          @param pObject : pointer to object 
17387      """ 
17388   
17389      _fl_set_xyplot_ybounds = cfuncproto( 
17390              load_so_libforms(), "fl_set_xyplot_ybounds", 
17391              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 
17392              """void fl_set_xyplot_ybounds(FL_OBJECT * ob, double ymin, 
17393                 double ymax) 
17394              """) 
17395      fminbound = convert_to_double(minbound) 
17396      fmaxbound = convert_to_double(maxbound) 
17397      keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 
17398      _fl_set_xyplot_ybounds(pObject, fminbound, fmaxbound) 
17399   
17400   
17401  #def fl_get_xyplot_xbounds(pObject, minbound, maxbound)       *API change* 
17402 -def fl_get_xyplot_xbounds(pObject): 
17403      """ 
17404          fl_get_xyplot_xbounds(pObject) -> minbound, maxbound 
17405   
17406          @param pObject : pointer to object 
17407      """ 
17408   
17409      _fl_get_xyplot_xbounds = cfuncproto( 
17410              load_so_libforms(), "fl_get_xyplot_xbounds", 
17411              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17412              cty.POINTER(cty.c_float)], 
17413              """void fl_get_xyplot_xbounds(FL_OBJECT * ob, float * xmin, 
17414                 float * xmax) 
17415              """) 
17416      minbound, pminbound = make_float_and_pointer() 
17417      maxbound, pmaxbound = make_float_and_pointer() 
17418      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
17419      _fl_get_xyplot_xbounds(pObject, pminbound, pmaxbound) 
17420      return minbound, maxbound 
17421   
17422   
17423  #def fl_get_xyplot_ybounds(pObject, minbound, maxbound)       *API change* 
17424 -def fl_get_xyplot_ybounds(pObject): 
17425      """ 
17426          fl_get_xyplot_ybounds(pObject) -> minbound, maxbound 
17427   
17428          @param pObject : pointer to object 
17429      """ 
17430   
17431      _fl_get_xyplot_ybounds = cfuncproto( 
17432              load_so_libforms(), "fl_get_xyplot_ybounds", 
17433              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17434              cty.POINTER(cty.c_float)], 
17435              """void fl_get_xyplot_ybounds(FL_OBJECT * ob, float * ymin, 
17436                 float * ymax) 
17437              """) 
17438      minbound, pminbound = make_float_and_pointer() 
17439      maxbound, pmaxbound = make_float_and_pointer() 
17440      keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 
17441      _fl_get_xyplot_ybounds(pObject, pminbound, pmaxbound) 
17442      return minbound, maxbound 
17443   
17444   
17445  #def fl_get_xyplot(pObject, x, y, i)       *API change* 
17446 -def fl_get_xyplot(pObject): 
17447      """ 
17448          fl_get_xyplot(pObject) -> x, y, i 
17449   
17450          @param pObject : pointer to object 
17451      """ 
17452   
17453      _fl_get_xyplot = cfuncproto( 
17454              load_so_libforms(), "fl_get_xyplot", 
17455              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17456              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17457              """void fl_get_xyplot(FL_OBJECT * ob, float * x, float * y, 
17458                 int * i) 
17459              """) 
17460      x, px = make_float_and_pointer() 
17461      y, py = make_float_and_pointer() 
17462      i, pi = make_int_and_pointer() 
17463      keep_elem_refs(pObject, x, y, i, px, py, pi) 
17464      _fl_get_xyplot(pObject, px, py, pi) 
17465      return x, y, i 
17466   
17467   
17468  #def fl_get_xyplot_data(pObject, x, y, n)       *API change* 
17469 -def fl_get_xyplot_data(pObject): 
17470      """ 
17471          fl_get_xyplot_data(pObject) -> x, y, n 
17472   
17473          @param pObject : pointer to object 
17474      """ 
17475   
17476      _fl_get_xyplot_data = cfuncproto( 
17477              load_so_libforms(), "fl_get_xyplot_data", 
17478              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17479              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17480              """void fl_get_xyplot_data(FL_OBJECT * ob, float * x, float * y, 
17481                 int * n) 
17482              """) 
17483      x, px = make_float_and_pointer() 
17484      y, py = make_float_and_pointer() 
17485      n, pn = make_int_and_pointer() 
17486      keep_elem_refs(pObject, x, y, n, px, py, pn) 
17487      _fl_get_xyplot_data(pObject, px, py, pn) 
17488      return x, y, n 
17489   
17490   
17491  #def fl_get_xyplot_data_pointer(pObject, idnum, x, y, n)       *API change* 
17492 -def fl_get_xyplot_data_pointer(pObject, idnum): 
17493      """ 
17494          fl_get_xyplot_data_pointer(pObject, idnum) -> x, y, n 
17495   
17496          @param pObject : pointer to object 
17497      """ 
17498   
17499      _fl_get_xyplot_data_pointer = cfuncproto( 
17500              load_so_libforms(), "fl_get_xyplot_data_pointer", 
17501              None, [cty.POINTER(FL_OBJECT), cty.c_int, 
17502              cty.POINTER(cty.POINTER(cty.c_float)), 
17503              cty.POINTER(cty.POINTER(cty.c_float)), cty.POINTER(cty.c_int)], 
17504              """void fl_get_xyplot_data_cty.POINTER(FL_OBJECT * ob, int id, 
17505                 float * * x, float * * y, int * n) 
17506              """) 
17507      iidnum = convert_to_int(idnum) 
17508      x, px = make_float_and_pointer() 
17509      y, py = make_float_and_pointer() 
17510      n, pn = make_int_and_pointer() 
17511      keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 
17512      _fl_get_xyplot_data_pointer(pObject, iidnum, px, py, pn) 
17513      return x, y, n 
17514   
17515   
17516  #def fl_get_xyplot_overlay_data(pObject, idnum, x, y, n)       *API change* 
17517 -def fl_get_xyplot_overlay_data(pObject, idnum): 
17518      """ 
17519          fl_get_xyplot_overlay_data(pObject, idnum) -> x, y, n 
17520   
17521          @param pObject : pointer to object 
17522      """ 
17523   
17524      _fl_get_xyplot_overlay_data = cfuncproto( 
17525              load_so_libforms(), "fl_get_xyplot_overlay_data", 
17526              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 
17527              cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 
17528              """void fl_get_xyplot_overlay_data(FL_OBJECT * ob, int id, 
17529                 float * x, float * y, int * n) 
17530              """) 
17531      iidnum = convert_to_int(idnum) 
17532      x, px = make_float_and_pointer() 
17533      y, py = make_float_and_pointer() 
17534      n, pn = make_int_and_pointer() 
17535      keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 
17536      _fl_get_xyplot_overlay_data(pObject, iidnum, px, py, pn) 
17537      return x, y, n 
17538   
17539   
17540 -def fl_set_xyplot_overlay_type(pObject, idnum, plottype): 
17541      """ 
17542          fl_set_xyplot_overlay_type(pObject, idnum, plottype) 
17543   
17544          @param pObject : pointer to object 
17545      """ 
17546   
17547      _fl_set_xyplot_overlay_type = cfuncproto( 
17548              load_so_libforms(), "fl_set_xyplot_overlay_type", 
17549              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17550              """void fl_set_xyplot_overlay_type(FL_OBJECT * ob, int id, 
17551                 int type) 
17552              """) 
17553      iidnum = convert_to_int(idnum) 
17554      iplottype = convert_to_int(plottype) 
17555      keep_elem_refs(pObject, idnum, plottype, iidnum, iplottype) 
17556      _fl_set_xyplot_overlay_type(pObject, iidnum, iplottype) 
17557   
17558   
17559 -def fl_delete_xyplot_overlay(pObject, idnum): 
17560      """ 
17561          fl_delete_xyplot_overlay(pObject, idnum) 
17562   
17563          @param pObject : pointer to object 
17564      """ 
17565   
17566      _fl_delete_xyplot_overlay = cfuncproto( 
17567              load_so_libforms(), "fl_delete_xyplot_overlay", 
17568              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17569              """void fl_delete_xyplot_overlay(FL_OBJECT * ob, int id) 
17570              """) 
17571      iidnum = convert_to_int(idnum) 
17572      keep_elem_refs(pObject, idnum, iidnum) 
17573      _fl_delete_xyplot_overlay(pObject, iidnum) 
17574   
17575   
17576 -def fl_set_xyplot_interpolate(pObject, idnum, deg, grid): 
17577      """ 
17578          fl_set_xyplot_interpolate(pObject, idnum, deg, grid) 
17579   
17580          @param pObject : pointer to object 
17581      """ 
17582   
17583      _fl_set_xyplot_interpolate = cfuncproto( 
17584              load_so_libforms(), "fl_set_xyplot_interpolate", 
17585              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 
17586              cty.c_double], 
17587              """void fl_set_xyplot_interpolate(FL_OBJECT * ob, int id, 
17588                 int deg, double grid) 
17589              """) 
17590      iidnum = convert_to_int(idnum) 
17591      ideg = convert_to_int(deg) 
17592      fgrid = convert_to_double(grid) 
17593      keep_elem_refs(pObject, idnum, deg, grid, iidnum, ideg, fgrid) 
17594      _fl_set_xyplot_interpolate(pObject, iidnum, ideg, fgrid) 
17595   
17596   
17597 -def fl_set_xyplot_inspect(pObject, yes): 
17598      """ 
17599          fl_set_xyplot_inspect(pObject, yes) 
17600   
17601          @param pObject : pointer to object 
17602      """ 
17603   
17604      _fl_set_xyplot_inspect = cfuncproto( 
17605              load_so_libforms(), "fl_set_xyplot_inspect", 
17606              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17607              """void fl_set_xyplot_inspect(FL_OBJECT * ob, int yes) 
17608              """) 
17609      iyes = convert_to_int(yes) 
17610      keep_elem_refs(pObject, yes, iyes) 
17611      _fl_set_xyplot_inspect(pObject, iyes) 
17612   
17613   
17614 -def fl_set_xyplot_symbolsize(pObject, n): 
17615      """ 
17616          fl_set_xyplot_symbolsize(pObject, n) 
17617   
17618          @param pObject : pointer to object 
17619      """ 
17620   
17621      _fl_set_xyplot_symbolsize = cfuncproto( 
17622              load_so_libforms(), "fl_set_xyplot_symbolsize", 
17623              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17624              """void fl_set_xyplot_symbolsize(FL_OBJECT * ob, int n) 
17625              """) 
17626      inum = convert_to_int(n) 
17627      keep_elem_refs(pObject, n, inum) 
17628      _fl_set_xyplot_symbolsize(pObject, inum) 
17629   
17630   
17631 -def fl_replace_xyplot_point(pObject, i, valx, valy): 
17632      """ 
17633          fl_replace_xyplot_point(pObject, i, valx, valy) 
17634   
17635          @param pObject : pointer to object 
17636      """ 
17637   
17638      _fl_replace_xyplot_point = cfuncproto( 
17639              load_so_libforms(), "fl_replace_xyplot_point", 
17640              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, 
17641              cty.c_double], 
17642              """void fl_replace_xyplot_point(FL_OBJECT * ob, int i, 
17643                 double x, double y) 
17644              """) 
17645      ii = convert_to_int(i) 
17646      fvalx = convert_to_double(valx) 
17647      fvaly = convert_to_double(valy) 
17648      keep_elem_refs(pObject, i, valx, valy, ii, fvalx, fvaly) 
17649      _fl_replace_xyplot_point(pObject, ii, fvalx, fvaly) 
17650   
17651   
17652  # Replace the value of a particular point in dataset setID, 
17653  # where setID=0 is the first data set. 
17654  # This routine is an extension of fl_replace_xyplot_point 
17655  # which acts on the first dataset only. 
17656   
17657 -def fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy): 
17658      """ 
17659          fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy) 
17660   
17661          @param pObject : pointer to object 
17662      """ 
17663   
17664      _fl_replace_xyplot_point_in_overlay = cfuncproto( 
17665              load_so_libforms(), "fl_replace_xyplot_point_in_overlay", 
17666              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, \ 
17667              cty.c_double, cty.c_double], 
17668              """void fl_replace_xyplot_point_in_overlay(FL_OBJECT * ob, 
17669                 int i, int setID, double x, double y) 
17670              """) 
17671      ii = convert_to_int(i) 
17672      isetID = convert_to_int(setID) 
17673      fvalx = convert_to_double(valx) 
17674      fvaly = convert_to_double(valy) 
17675      keep_elem_refs(pObject, i, setID, valx, valy, ii, isetID, fvalx, fvaly) 
17676      _fl_replace_xyplot_point_in_overlay(pObject, ii, isetID, fvalx, fvaly) 
17677   
17678   
17679  #def fl_get_xyplot_xmapping(pObject, a, b)       *API change* 
17680 -def fl_get_xyplot_xmapping(pObject): 
17681      """ 
17682          fl_get_xyplot_xmapping(pObject) -> a, b 
17683   
17684          @param pObject : pointer to object 
17685      """ 
17686   
17687      _fl_get_xyplot_xmapping = cfuncproto( 
17688              load_so_libforms(), "fl_get_xyplot_xmapping", 
17689              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17690              cty.POINTER(cty.c_float)], 
17691              """void fl_get_xyplot_xmapping(FL_OBJECT * ob, float * a, 
17692                 float * b) 
17693              """) 
17694      a, pa = make_float_and_pointer() 
17695      b, pb = make_float_and_pointer() 
17696      keep_elem_refs(pObject, a, b, pa, pb) 
17697      _fl_get_xyplot_xmapping(pObject, pa, pb) 
17698      return a, b 
17699   
17700   
17701  #def fl_get_xyplot_ymapping(pObject, a, b)       *API change* 
17702 -def fl_get_xyplot_ymapping(pObject): 
17703      """ 
17704          fl_get_xyplot_ymapping(pObject) -> a, b 
17705   
17706          @param pObject : pointer to object 
17707      """ 
17708   
17709      _fl_get_xyplot_ymapping = cfuncproto( 
17710              load_so_libforms(), "fl_get_xyplot_ymapping", 
17711              None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 
17712              cty.POINTER(cty.c_float)], 
17713              """void fl_get_xyplot_ymapping(FL_OBJECT * ob, float * a, 
17714                 float * b) 
17715              """) 
17716      a, pa = make_float_and_pointer() 
17717      b, pb = make_float_and_pointer() 
17718      keep_elem_refs(pObject, a, b, pa, pb) 
17719      _fl_get_xyplot_ymapping(pObject, pa, pb) 
17720      return a, b 
17721   
17722   
17723 -def fl_set_xyplot_keys(pObject, keys, valx, valy, align): 
17724      """ 
17725          fl_set_xyplot_keys(pObject, keys, valx, valy, align) 
17726   
17727          @param pObject : pointer to object 
17728      """ 
17729   
17730      _fl_set_xyplot_keys = cfuncproto( 
17731              load_so_libforms(), "fl_set_xyplot_keys", 
17732              None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING), cty.c_float, 
17733              cty.c_float, cty.c_int], 
17734              """void fl_set_xyplot_keys(FL_OBJECT * ob, char * * keys, float x, 
17735                 float y, int align) 
17736              """) 
17737      fvalx = convert_to_float(valx) 
17738      fvaly = convert_to_float(valy) 
17739      ialign = convert_to_int(align) 
17740      keep_elem_refs(pObject, keys, valx, valy, align, fvalx, fvaly, ialign) 
17741      _fl_set_xyplot_keys(pObject, keys, fvalx, fvaly, ialign) 
17742   
17743   
17744 -def fl_set_xyplot_key(pObject, idnum, keytxt): 
17745      """ 
17746          fl_set_xyplot_key(pObject, idnum, keytxt) 
17747   
17748          @param pObject : pointer to object 
17749      """ 
17750   
17751      _fl_set_xyplot_key = cfuncproto( 
17752              load_so_libforms(), "fl_set_xyplot_key", 
17753              None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 
17754              """void fl_set_xyplot_key(FL_OBJECT * ob, int id, 
17755                 const char * key) 
17756              """) 
17757      iidnum = convert_to_int(idnum) 
17758      skeytxt = convert_to_string(keytxt) 
17759      keep_elem_refs(pObject, idnum, keytxt, iidnum, skeytxt) 
17760      _fl_set_xyplot_key(pObject, iidnum, skeytxt) 
17761   
17762   
17763 -def fl_set_xyplot_key_position(pObject, valx, valy, align): 
17764      """ 
17765          fl_set_xyplot_key_position(pObject, valx, valy, align) 
17766   
17767          @param pObject : pointer to object 
17768      """ 
17769   
17770      _fl_set_xyplot_key_position = cfuncproto( 
17771              load_so_libforms(), "fl_set_xyplot_key_position", 
17772              None, [cty.POINTER(FL_OBJECT), cty.c_float, cty.c_float, 
17773              cty.c_int], 
17774              """void fl_set_xyplot_key_position(FL_OBJECT * ob, float x, 
17775                 float y, int align) 
17776              """) 
17777      fvalx = convert_to_float(valx) 
17778      fvaly = convert_to_float(valy) 
17779      ialign = convert_to_int(align) 
17780      keep_elem_refs(pObject, valx, valy, align, fvalx, fvaly, ialign) 
17781      _fl_set_xyplot_key_position(pObject, fvalx, fvaly, ialign) 
17782   
17783   
17784 -def fl_set_xyplot_key_font(pObject, style, size): 
17785      """ 
17786          fl_set_xyplot_key_font(pObject, style, size) 
17787   
17788          @param pObject : pointer to object 
17789      """ 
17790   
17791      _fl_set_xyplot_key_font = cfuncproto( 
17792              load_so_libforms(), "fl_set_xyplot_key_font", 
17793              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17794              """void fl_set_xyplot_key_font(FL_OBJECT * ob, int style, 
17795                 int size) 
17796              """) 
17797      istyle = convert_to_int(style) 
17798      isize = convert_to_int(size) 
17799      keep_elem_refs(pObject, style, size, istyle, isize) 
17800      _fl_set_xyplot_key_font(pObject, istyle, isize) 
17801   
17802   
17803 -def fl_get_xyplot_numdata(pObject, idnum): 
17804      """ 
17805          fl_get_xyplot_numdata(pObject, idnum) -> num. 
17806   
17807          @param pObject : pointer to object 
17808      """ 
17809   
17810      _fl_get_xyplot_numdata = cfuncproto( 
17811              load_so_libforms(), "fl_get_xyplot_numdata", 
17812              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
17813              """int fl_get_xyplot_numdata(FL_OBJECT * ob, int id) 
17814              """) 
17815      iidnum = convert_to_int(idnum) 
17816      keep_elem_refs(pObject, idnum, iidnum) 
17817      retval = _fl_get_xyplot_numdata(pObject, iidnum) 
17818      return retval 
17819   
17820   
17821  # The following two functions will be removed. 
17822  # Use fl_set_object_l[size|style] for the functionalities 
17823   
17824 -def fl_set_xyplot_fontsize(pObject, size): 
17825      """ 
17826          fl_set_xyplot_fontsize(pObject, size) 
17827   
17828          @param pObject : pointer to object 
17829      """ 
17830   
17831      _fl_set_xyplot_fontsize = cfuncproto( 
17832              load_so_libforms(), "fl_set_xyplot_fontsize", 
17833              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17834              """void fl_set_xyplot_fontsize(FL_OBJECT * ob, int size) DEPRECATED 
17835              """) 
17836      warn_deprecated_function("Use fl_set_lsize, instead.") 
17837      isize = convert_to_int(size) 
17838      keep_elem_refs(pObject, size, isize) 
17839      _fl_set_xyplot_fontsize(pObject, isize) 
17840   
17841   
17842 -def fl_set_xyplot_fontstyle(pObject, style): 
17843      """ 
17844          fl_set_xyplot_fontstyle(pObject, style) 
17845   
17846          @param pObject : pointer to object 
17847      """ 
17848   
17849      _fl_set_xyplot_fontstyle = cfuncproto( 
17850              load_so_libforms(), "fl_set_xyplot_fontstyle", 
17851              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17852              """void fl_set_xyplot_fontstyle(FL_OBJECT * ob, int style) DEPRECATED 
17853              """) 
17854      warn_deprecated_function("Use fl_set_lstyle, instead.") 
17855      istyle = convert_to_int(style) 
17856      keep_elem_refs(pObject, style, istyle) 
17857      _fl_set_xyplot_fontstyle(pObject, istyle) 
17858   
17859   
17860 -def fl_xyplot_s2w(pObject, sx, sy, wx, wy): 
17861      """ 
17862          fl_xyplot_s2w(pObject, sx, sy, wx, wy) 
17863   
17864          @param pObject : pointer to object 
17865      """ 
17866   
17867      _fl_xyplot_s2w = cfuncproto( 
17868              load_so_libforms(), "fl_xyplot_s2w", 
17869              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 
17870              cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 
17871              """void fl_xyplot_s2w(FL_OBJECT * ob, double sx, double sy, 
17872                 float * wx, float * wy) 
17873              """) 
17874      fsx = convert_to_double(sx) 
17875      fsy = convert_to_double(sy) 
17876      keep_elem_refs(pObject, sx, sy, wx, wy, fsx, fsy) 
17877      _fl_xyplot_s2w(pObject, fsx, fsy, wx, wy) 
17878   
17879   
17880 -def fl_xyplot_w2s(pObject, wx, wy, sx, sy): 
17881      """ 
17882          fl_xyplot_w2s(pObject, wx, wy, sx, sy) 
17883   
17884          @param pObject : pointer to object 
17885      """ 
17886   
17887      _fl_xyplot_w2s = cfuncproto( 
17888              load_so_libforms(), "fl_xyplot_w2s", 
17889              None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 
17890              cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 
17891              """void fl_xyplot_w2s(FL_OBJECT * ob, double wx, double wy, 
17892                 float * sx, float * sy) 
17893              """) 
17894      fwx = convert_to_double(wx) 
17895      fwy = convert_to_double(wy) 
17896      keep_elem_refs(pObject, wx, wy, sx, sy, fwx, fwy) 
17897      _fl_xyplot_w2s(pObject, fwx, fwy, sx, sy) 
17898   
17899   
17900 -def fl_set_xyplot_xscale(pObject, scale, base): 
17901      """ 
17902          fl_set_xyplot_xscale(pObject, scale, base) 
17903   
17904          @param pObject : pointer to object 
17905      """ 
17906   
17907      _fl_set_xyplot_xscale = cfuncproto( 
17908              load_so_libforms(), "fl_set_xyplot_xscale", 
17909              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 
17910              """void fl_set_xyplot_xscale(FL_OBJECT * ob, int scale, 
17911                 double base) 
17912              """) 
17913      iscale = convert_to_int(scale) 
17914      fbase = convert_to_double(base) 
17915      keep_elem_refs(pObject, scale, base, iscale, fbase) 
17916      _fl_set_xyplot_xscale(pObject, iscale, fbase) 
17917   
17918   
17919 -def fl_set_xyplot_yscale(pObject, scale, base): 
17920      """ 
17921          fl_set_xyplot_yscale(pObject, scale, base) 
17922   
17923          @param pObject : pointer to object 
17924      """ 
17925   
17926      _fl_set_xyplot_yscale = cfuncproto( 
17927              load_so_libforms(), "fl_set_xyplot_yscale", 
17928              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 
17929              """void fl_set_xyplot_yscale(FL_OBJECT * ob, int scale, 
17930                 double base) 
17931              """) 
17932      iscale = convert_to_int(scale) 
17933      fbase = convert_to_double(base) 
17934      keep_elem_refs(pObject, scale, base, iscale, fbase) 
17935      _fl_set_xyplot_yscale(pObject, iscale, fbase) 
17936   
17937   
17938 -def fl_clear_xyplot(pObject): 
17939      """ 
17940          fl_clear_xyplot(pObject) 
17941   
17942          @param pObject : pointer to object 
17943      """ 
17944   
17945      _fl_clear_xyplot = cfuncproto( 
17946              load_so_libforms(), "fl_clear_xyplot", 
17947              None, [cty.POINTER(FL_OBJECT)], 
17948              """void fl_clear_xyplot(FL_OBJECT * ob) 
17949              """) 
17950      keep_elem_refs(pObject) 
17951      _fl_clear_xyplot(pObject) 
17952   
17953   
17954 -def fl_set_xyplot_linewidth(pObject, idnum, lw): 
17955      """ 
17956          fl_set_xyplot_linewidth(pObject, idnum, lw) 
17957   
17958          @param pObject : pointer to object 
17959      """ 
17960   
17961      _fl_set_xyplot_linewidth = cfuncproto( 
17962              load_so_libforms(), "fl_set_xyplot_linewidth", 
17963              None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 
17964              """void fl_set_xyplot_linewidth(FL_OBJECT * ob, int id, int lw) 
17965              """) 
17966      iidnum = convert_to_int(idnum) 
17967      ilw = convert_to_int(lw) 
17968      keep_elem_refs(pObject, idnum, lw, iidnum, ilw) 
17969      _fl_set_xyplot_linewidth(pObject, iidnum, ilw) 
17970   
17971   
17972 -def fl_set_xyplot_xgrid(pObject, xgrid): 
17973      """ 
17974          fl_set_xyplot_xgrid(pObject, xgrid) 
17975   
17976          @param pObject : pointer to object 
17977      """ 
17978   
17979      _fl_set_xyplot_xgrid = cfuncproto( 
17980              load_so_libforms(), "fl_set_xyplot_xgrid", 
17981              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17982              """void fl_set_xyplot_xgrid(FL_OBJECT * ob, int xgrid) 
17983              """) 
17984      ixgrid = convert_to_int(xgrid) 
17985      keep_elem_refs(pObject, xgrid, ixgrid) 
17986      _fl_set_xyplot_xgrid(pObject, ixgrid) 
17987   
17988   
17989 -def fl_set_xyplot_ygrid(pObject, ygrid): 
17990      """ 
17991          fl_set_xyplot_ygrid(pObject, ygrid) 
17992   
17993          @param pObject : pointer to object 
17994      """ 
17995   
17996      _fl_set_xyplot_ygrid = cfuncproto( 
17997              load_so_libforms(), "fl_set_xyplot_ygrid", 
17998              None, [cty.POINTER(FL_OBJECT), cty.c_int], 
17999              """void fl_set_xyplot_ygrid(FL_OBJECT * ob, int ygrid) 
18000              """) 
18001      iygrid = convert_to_int(ygrid) 
18002      keep_elem_refs(pObject, ygrid, iygrid) 
18003      _fl_set_xyplot_ygrid(pObject, iygrid) 
18004   
18005   
18006 -def fl_set_xyplot_grid_linestyle(pObject, style): 
18007      """ 
18008          fl_set_xyplot_grid_linestyle(pObject, style) -> num. 
18009   
18010          @param pObject : pointer to object 
18011      """ 
18012   
18013      _fl_set_xyplot_grid_linestyle = cfuncproto( 
18014              load_so_libforms(), "fl_set_xyplot_grid_linestyle", 
18015              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
18016              """int fl_set_xyplot_grid_linestyle(FL_OBJECT * ob, int style) 
18017              """) 
18018      istyle = convert_to_int(style) 
18019      keep_elem_refs(pObject, style, istyle) 
18020      retval = _fl_set_xyplot_grid_linestyle(pObject, istyle) 
18021      return retval 
18022   
18023   
18024 -def fl_set_xyplot_alphaxtics(pObject, m, s): 
18025      """ 
18026          fl_set_xyplot_alphaxtics(pObject, m, s) 
18027   
18028          @param pObject : pointer to object 
18029      """ 
18030   
18031      _fl_set_xyplot_alphaxtics = cfuncproto( 
18032              load_so_libforms(), "fl_set_xyplot_alphaxtics", 
18033              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18034              """void fl_set_xyplot_alphaxtics(FL_OBJECT * ob, const char * m, 
18035                 const char * s) 
18036              """) 
18037      sm = convert_to_string(m) 
18038      ss = convert_to_string(s) 
18039      keep_elem_refs(pObject, m, s, sm, ss) 
18040      _fl_set_xyplot_alphaxtics(pObject, sm, ss) 
18041   
18042   
18043 -def fl_set_xyplot_alphaytics(pObject, m, s): 
18044      """ 
18045          fl_set_xyplot_alphaytics(pObject, m, s) 
18046   
18047          @param pObject : pointer to object 
18048      """ 
18049   
18050      _fl_set_xyplot_alphaytics = cfuncproto( 
18051              load_so_libforms(), "fl_set_xyplot_alphaytics", 
18052              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18053              """void fl_set_xyplot_alphaytics(FL_OBJECT * ob, const char * m, 
18054                 const char * s) 
18055              """) 
18056      sm = convert_to_string(m) 
18057      ss = convert_to_string(s) 
18058      keep_elem_refs(pObject, m, s, sm, ss) 
18059      _fl_set_xyplot_alphaytics(pObject, sm, ss) 
18060   
18061   
18062 -def fl_set_xyplot_fixed_xaxis(pObject, lm, rm): 
18063      """ 
18064          fl_set_xyplot_fixed_xaxis(pObject, lm, rm) 
18065   
18066          @param pObject : pointer to object 
18067      """ 
18068   
18069      _fl_set_xyplot_fixed_xaxis = cfuncproto( 
18070              load_so_libforms(), "fl_set_xyplot_fixed_xaxis", 
18071              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18072              """void fl_set_xyplot_fixed_xaxis(FL_OBJECT * ob, const char * lm, 
18073                 const char * rm) 
18074              """) 
18075      slm = convert_to_string(lm) 
18076      srm = convert_to_string(rm) 
18077      keep_elem_refs(pObject, lm, rm, slm, srm) 
18078      _fl_set_xyplot_fixed_xaxis(pObject, slm, srm) 
18079   
18080   
18081 -def fl_set_xyplot_fixed_yaxis(pObject, bm, tm): 
18082      """ 
18083          fl_set_xyplot_fixed_yaxis(pObject, bm, tm) 
18084   
18085          @param pObject : pointer to object 
18086      """ 
18087   
18088      _fl_set_xyplot_fixed_yaxis = cfuncproto( 
18089              load_so_libforms(), "fl_set_xyplot_fixed_yaxis", 
18090              None, [cty.POINTER(FL_OBJECT), STRING, STRING], 
18091              """void fl_set_xyplot_fixed_yaxis(FL_OBJECT * ob, const char * bm, 
18092                 const char * tm) 
18093              """) 
18094      sbm = convert_to_string(bm) 
18095      stm = convert_to_string(tm) 
18096      keep_elem_refs(pObject, bm, tm, sbm, stm) 
18097      _fl_set_xyplot_fixed_yaxis(pObject, sbm, stm) 
18098   
18099   
18100 -def fl_interpolate(wx, wy, nin, x, y, grid, ndeg): 
18101      """ 
18102          fl_interpolate(wx, wy, nin, x, y, grid, ndeg) -> num. 
18103      """ 
18104   
18105      _fl_interpolate = cfuncproto( 
18106              load_so_libforms(), "fl_interpolate", 
18107              cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18108              cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18109              cty.c_double, cty.c_int], 
18110              """int fl_interpolate(const char * wx, const char * wy, int nin, 
18111                 float * x, float * y, double grid, int ndeg) 
18112              """) 
18113      inin = convert_to_int(nin) 
18114      fgrid = convert_to_double(grid) 
18115      indeg = convert_to_int(ndeg) 
18116      keep_elem_refs(wx, wy, nin, x, y, grid, ndeg, inin, fgrid, indeg) 
18117      retval = _fl_interpolate(wx, wy, inin, x, y, fgrid, indeg) 
18118      return retval 
18119   
18120   
18121 -def fl_spline_interpolate(wx, wy, nin, x, y, grid): 
18122      """ 
18123          fl_spline_interpolate(wx, wy, nin, x, y, grid) -> num. 
18124      """ 
18125   
18126      _fl_spline_interpolate = cfuncproto( 
18127              load_so_libforms(), "fl_spline_interpolate", 
18128              cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18129              cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 
18130              cty.c_double], 
18131              """int fl_spline_interpolate(const char * wx, const char * wy, 
18132                 int nin, float * x, float * y, double grid) 
18133              """) 
18134      inin = convert_to_int(nin) 
18135      fgrid = convert_to_double(grid) 
18136      keep_elem_refs(wx, wy, nin, x, y, grid, inin, fgrid) 
18137      retval = _fl_spline_interpolate(wx, wy, inin, x, y, fgrid) 
18138      return retval 
18139   
18140   
18141  FL_XYPLOT_SYMBOL = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_int, 
18142              cty.POINTER(FL_POINT), cty.c_int, cty.c_int, cty.c_int) 
18143   
18144 -def fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol): 
18145      """ 
18146          fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol) -> xyplot_symbol func. 
18147   
18148          @param pObject : pointer to object 
18149      """ 
18150   
18151      _fl_set_xyplot_symbol = cfuncproto( 
18152              load_so_libforms(), "fl_set_xyplot_symbol", 
18153              FL_XYPLOT_SYMBOL, [cty.POINTER(FL_OBJECT), cty.c_int, 
18154              FL_XYPLOT_SYMBOL], 
18155              """FL_XYPLOT_SYMBOL fl_set_xyplot_symbol(FL_OBJECT * ob, int id, 
18156                 FL_XYPLOT_SYMBOL symbol) 
18157              """) 
18158      iidnum = convert_to_int(idnum) 
18159      c_XyPlotSymbol = FL_XYPLOT_SYMBOL(py_XyPlotSymbol) 
18160      keep_cfunc_refs(c_XyPlotSymbol, py_XyPlotSymbol) 
18161      keep_elem_refs(pObject, idnum, iidnum) 
18162      retval = _fl_set_xyplot_symbol(pObject, iidnum, c_XyPlotSymbol) 
18163      return retval 
18164   
18165   
18166 -def fl_set_xyplot_mark_active(pObject, y): 
18167      """ 
18168          fl_set_xyplot_mark_active(pObject, y) -> num. 
18169   
18170          @param pObject : pointer to object 
18171      """ 
18172   
18173      _fl_set_xyplot_mark_active = cfuncproto( 
18174              load_so_libforms(), "fl_set_xyplot_mark_active", 
18175              cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 
18176              """int fl_set_xyplot_mark_active(FL_OBJECT * ob, int y) 
18177              """) 
18178      iy = convert_to_int(y) 
18179      keep_elem_refs(pObject, y, iy) 
18180      retval = _fl_set_xyplot_mark_active(pObject, iy) 
18181      return retval 
18182   
18183   
18184  # the following (fl_fheight) etc. were never documented and were 
18185  # removed from V0.89, but apparently this broke some applications that 
18186  # were using them. Put them back in 10/22/00 
18187   
18188 -def fl_gc_(): 
18189      """ 
18190          fl_gc_() -> gc 
18191      """ 
18192   
18193      _fl_gc_ = cfuncproto( 
18194              load_so_libforms(), "fl_gc_", 
18195              GC, [], 
18196              """GC fl_gc_() 
18197              """) 
18198      retval = _fl_gc_() 
18199      return retval 
18200   
18201   
18202 -def fl_textgc_(): 
18203      """ 
18204          fl_textgc_() -> gc 
18205      """ 
18206   
18207      _fl_textgc_ = cfuncproto( 
18208              load_so_libforms(), "fl_textgc_", 
18209              GC, [], 
18210              """)GC fl_textgc_() 
18211              """) 
18212      retval = _fl_textgc_() 
18213      return retval 
18214   
18215   
18216 -def fl_fheight_(): 
18217      """ 
18218          fl_fheight_() -> num. 
18219      """ 
18220   
18221      _fl_fheight_ = cfuncproto( 
18222              load_so_libforms(), "fl_fheight_", 
18223              cty.c_int, [], 
18224              """int fl_fheight_() 
18225              """) 
18226      retval = _fl_fheight_() 
18227      return retval 
18228   
18229   
18230 -def fl_fdesc_(): 
18231      """ 
18232          fl_fdesc_() -> num. 
18233      """ 
18234   
18235      _fl_fdesc_ = cfuncproto( 
18236              load_so_libforms(), "fl_fdesc_", 
18237              cty.c_int, [], 
18238              """int fl_fdesc_() 
18239              """) 
18240      retval = _fl_fdesc_() 
18241      return retval 
18242   
18243   
18244 -def fl_cur_win_(): 
18245      """ 
18246          fl_cur_win_() -> window 
18247      """ 
18248   
18249      _fl_cur_win_ = cfuncproto( 
18250              load_so_libforms(), "fl_cur_win_", 
18251              Window, [], 
18252              """Window fl_cur_win_() 
18253              """) 
18254      retval = _fl_cur_win_() 
18255      return retval 
18256   
18257   
18258 -def fl_cur_fs_(): 
18259      """ 
18260          fl_cur_fs_() -> XFontStruct class 
18261      """ 
18262   
18263      _fl_cur_fs_ = cfuncproto( 
18264              load_so_libforms(), "fl_cur_fs_", 
18265              cty.POINTER(XFontStruct), [], 
18266              """XFontStruct * fl_cur_fs_() 
18267              """) 
18268      retval = _fl_cur_fs_() 
18269      return retval 
18270   
18271   
18272  # commented to prevent a SegmentationFault during installation --LK 
18273  #fl_textgc = fl_textgc_() 
18274  fl_textgc = fl_textgc_ 
18275  #fl_gc = fl_gc_() 
18276  fl_gc = fl_gc_ 
18277  #fl_cur_win = fl_cur_win_() 
18278  fl_cur_win = fl_cur_win_ 
18279  #fl_fheight = fl_fheight_() 
18280  fl_fheight = fl_fheight_ 
18281  #fl_fdesc = fl_fdesc_() 
18282  fl_fdesc = fl_fdesc_ 
18283  #fl_cur_fs = fl_cur_fs_() 
18284  fl_cur_fs = fl_cur_fs_ 
18285   
18286   
18287 -def fl_display_(): 
18288      """ 
18289          fl_display_() -> pDisplay 
18290      """ 
18291   
18292      _fl_display_ = cfuncproto( 
18293              load_so_libforms(), "fl_display_", 
18294              cty.POINTER(Display), [], 
18295              """Display * fl_display_() 
18296              """) 
18297      retval = _fl_display_() 
18298      return retval 
18299   
18300   
18301   
18302  ######################### 
18303  # flimage.h 
18304  # Image related routines 
18305  ######################### 
18306   
18307  # low-level, maybe unused in python --LK 
18308  #def fl_safe_free(p): 
18309  #    if p: 
18310  #        fl_free(p) 
18311  #        p = None        # UNSURE 
18312   
18313 -def FL_RGB2GRAY(r, g, b): 
18314      return cty.c_uint((78 * (r) + 150 * (g) + 28 * (b)) >> 8) 
18315   
18316   
18317  # if PCBITS is not 8, we need to apply the RGBmask 
18318   
18319 -def FL_IsRGB(pImage): 
18320      return (pImage.contents.type == FL_IMAGE_RGB) 
18321   
18322 -def FL_IsPacked(pImage): 
18323      return (pImage.contents.type == FL_IMAGE_PACKED) 
18324   
18325   
18326 -def flimage_setup(pImageSetup): 
18327      """ 
18328          flimage_setup(pImageSetup) 
18329   
18330          @param pImageSetup : pointer to imagesetup struct 
18331      """ 
18332   
18333      _flimage_setup = cfuncproto( 
18334              load_so_libflimage(), "flimage_setup", 
18335              None, [cty.POINTER(FLIMAGE_SETUP)], 
18336              """void flimage_setup(FLIMAGE_SETUP * setup) 
18337              """) 
18338      keep_elem_refs(pImageSetup) 
18339      _flimage_setup(pImageSetup) 
18340   
18341   
18342  # basic IO routines 
18343   
18344 -def flimage_load(filename): 
18345      """ 
18346          flimage_load(filename) -> pImage 
18347   
18348          @param filename : name of file to load 
18349      """ 
18350   
18351      _flimage_load = cfuncproto( 
18352              load_so_libflimage(), "flimage_load", 
18353              cty.POINTER(FL_IMAGE), [STRING], 
18354              """FL_IMAGE * flimage_load(const char * file) 
18355              """) 
18356      sfilename = convert_to_string(filename) 
18357      keep_elem_refs(filename, sfilename) 
18358      retval = _flimage_load(sfilename) 
18359      return retval 
18360   
18361   
18362 -def flimage_read(pImage): 
18363      """ 
18364          flimage_read(pImage) -> pImage 
18365   
18366          @param pImage : pointer to image 
18367      """ 
18368   
18369      _flimage_read = cfuncproto( 
18370              load_so_libflimage(), "flimage_read", 
18371              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 
18372              """FL_IMAGE * flimage_read(FL_IMAGE * im) 
18373              """) 
18374      keep_elem_refs(pImage) 
18375      retval = _flimage_read(pImage) 
18376      return retval 
18377   
18378   
18379 -def flimage_dump(pImage, p2, p3): 
18380      """ 
18381          flimage_dump(pImage, p2, p3) -> num. 
18382   
18383          @param pImage : pointer to image 
18384      """ 
18385   
18386      _flimage_dump = cfuncproto( 
18387              load_so_libflimage(), "flimage_dump", 
18388              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, STRING], 
18389              """int flimage_dump(FL_IMAGE * p1, const char * p2, 
18390                 const char * p3) 
18391              """) 
18392      sp2 = convert_to_string(p2) 
18393      sp3 = convert_to_string(p3) 
18394      keep_elem_refs(pImage, p2, p3, sp2, sp3) 
18395      retval = _flimage_dump(pImage, sp2, sp3) 
18396      return retval 
18397   
18398   
18399 -def flimage_close(pImage): 
18400      """ 
18401          flimage_close(pImage) -> num. 
18402   
18403          @param pImage : pointer to image 
18404      """ 
18405   
18406      _flimage_close = cfuncproto( 
18407              load_so_libflimage(), "flimage_close", 
18408              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18409              """int flimage_close(FL_IMAGE * p1) 
18410              """) 
18411      keep_elem_refs(pImage) 
18412      retval = _flimage_close(pImage) 
18413      return retval 
18414   
18415   
18416 -def flimage_alloc(): 
18417      """ 
18418          flimage_alloc() -> pImage 
18419      """ 
18420   
18421      _flimage_alloc = cfuncproto( 
18422              load_so_libflimage(), "flimage_alloc", 
18423              cty.POINTER(FL_IMAGE), [], 
18424              """FL_IMAGE * flimage_alloc() 
18425              """) 
18426      retval = _flimage_alloc() 
18427      return retval 
18428   
18429   
18430 -def flimage_getmem(pImage): 
18431      """ 
18432          flimage_getmem(pImage) -> num. 
18433   
18434          @param pImage : pointer to image 
18435      """ 
18436   
18437      _flimage_getmem = cfuncproto( 
18438              load_so_libflimage(), "flimage_getmem", 
18439              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18440              """int flimage_getmem(FL_IMAGE * p1) 
18441              """) 
18442      keep_elem_refs(pImage) 
18443      retval = _flimage_getmem(pImage) 
18444      return retval 
18445   
18446   
18447 -def flimage_is_supported(fname): 
18448      """ 
18449          flimage_is_supported(fname) -> num. 
18450   
18451          @param fname : filename 
18452      """ 
18453   
18454      _flimage_is_supported = cfuncproto( 
18455              load_so_libflimage(), "flimage_is_supported", 
18456              cty.c_int, [STRING], 
18457              """int flimage_is_supported(const char * p1) 
18458              """) 
18459      sfname = convert_to_string(fname) 
18460      keep_elem_refs(fname, sfname) 
18461      retval = _flimage_is_supported(sfname) 
18462      return retval 
18463   
18464   
18465 -def flimage_description_via_filter(pImage, p2, p3, p4): 
18466      """ 
18467          flimage_description_via_filter(pImage, p2, p3, p4) -> num. 
18468   
18469          @param pImage : pointer to image 
18470      """ 
18471   
18472      _flimage_description_via_filter = cfuncproto( 
18473              load_so_libflimage(), "flimage_description_via_filter", 
18474              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), STRING, 
18475              cty.c_int], 
18476              """int flimage_description_via_filter(FL_IMAGE * p1, 
18477                 const char * p2, const char * p3, int p4) 
18478              """) 
18479      sp3 = convert_to_string(p3) 
18480      ip4 = convert_to_string(p4) 
18481      keep_elem_refs(pImage, p2, p3, p4, sp3, ip4) 
18482      retval = _flimage_description_via_filter(pImage, p2, sp3, ip4) 
18483      return retval 
18484   
18485   
18486 -def flimage_write_via_filter(pImage, p2, p3, p4): 
18487      """ 
18488          flimage_write_via_filter(pImage, p2, p3, p4) -> num. 
18489   
18490          @param pImage : pointer to image 
18491      """ 
18492   
18493      _flimage_write_via_filter = cfuncproto( 
18494              load_so_libflimage(), "flimage_write_via_filter", 
18495              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), 
18496              cty.POINTER(STRING), cty.c_int], 
18497              """int flimage_write_via_filter(FL_IMAGE * p1, const char * p2, 
18498                 const char * p3, int p4) 
18499              """) 
18500      ip4 = convert_to_int(p4) 
18501      keep_elem_refs(pImage, p2, p3, p4, ip4) 
18502      retval = _flimage_write_via_filter(pImage, p2, p3, ip4) 
18503      return retval 
18504   
18505   
18506 -def flimage_free(pImage): 
18507      """ 
18508          flimage_free(pImage) -> num. 
18509   
18510          @param pImage : pointer to image 
18511      """ 
18512   
18513      _flimage_free = cfuncproto( 
18514              load_so_libflimage(), "flimage_free", 
18515              cty.c_int, [cty.POINTER(FL_IMAGE)], 
18516              """int flimage_free(FL_IMAGE * p1) 
18517              """) 
18518      keep_elem_refs(pImage) 
18519      retval = _flimage_free(pImage) 
18520      return retval 
18521   
18522   
18523 -def flimage_display(pImage, win): 
18524      """ 
18525          flimage_display(pImage, win) -> num. 
18526   
18527          @param pImage : pointer to image 
18528          @param win : window 
18529      """ 
18530   
18531      _flimage_display = cfuncproto( 
18532              load_so_libflimage(), "flimage_display", 
18533              cty.c_int, [cty.POINTER(FL_IMAGE), Window], 
18534              """int flimage_display(FL_IMAGE * p1, Window p2) 
18535              """) 
18536      ulwin = convert_to_Window(win) 
18537      keep_elem_refs(pImage, win, ulwin) 
18538      retval = _flimage_display(pImage, ulwin) 
18539      return retval 
18540   
18541   
18542 -def flimage_sdisplay(pImage, win): 
18543      """ 
18544          flimage_sdisplay(pImage, win) -> num. 
18545   
18546          @param pImage : pointer to image 
18547          @param win : window 
18548      """ 
18549   
18550      _flimage_sdisplay = cfuncproto( 
18551              load_so_libflimage(), "flimage_sdisplay", 
18552              cty.c_int, [cty.POINTER(FL_IMAGE), Window], 
18553              """int flimage_sdisplay(FL_IMAGE * p1, Window p2) 
18554              """) 
18555      ulwin = convert_to_Window(win) 
18556      keep_elem_refs(pImage, win, ulwin) 
18557      retval = _flimage_sdisplay(pImage, ulwin) 
18558      return retval 
18559   
18560   
18561 -def flimage_convert(pImage, newtype, ncolors): 
18562      """ 
18563          flimage_convert(pImage, newtype, ncolors) -> num. 
18564   
18565          Convert an image to a new type. 
18566   
18567          @param pImage : pointer to image 
18568          @param newtype : new type of flimage to convert to 
18569          @param ncolors : number of colors 
18570      """ 
18571   
18572      _flimage_convert = cfuncproto( 
18573              load_so_libflimage(), "flimage_convert", 
18574              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
18575              """int flimage_convert(FL_IMAGE * p1, int p2, int p3) 
18576              """) 
18577      inewtype2 = convert_to_int(newtype) 
18578      incolors = convert_to_int(ncolors) 
18579      keep_elem_refs(pImage, newtype, ncolors, inewtype, incolors) 
18580      retval = _flimage_convert(pImage, inewtype, incolors) 
18581      return retval 
18582   
18583   
18584 -def flimage_type_name(flimagetype): 
18585      """ 
18586          flimage_type_name(flimagetype) -> name string 
18587           
18588          @param flimagetype : type of flimage 
18589      """ 
18590   
18591      _flimage_type_name = cfuncproto( 
18592              load_so_libflimage(), "flimage_type_name", 
18593              STRING, [cty.c_int], 
18594              """const char * flimage_type_name(int type) 
18595              """) 
18596      check_admitted_values(flimagetype, FLIMAGETYPE_list) 
18597      iflimagetype = convert_to_int(flimagetype) 
18598      keep_elem_refs(flimagetype, iflimagetype) 
18599      retval = _flimage_type_name(iflimagetype) 
18600      return retval 
18601   
18602   
18603 -def flimage_add_text(pImage, text, length, style, size, txtcolr, bgcolr, tran, tx, ty, rot): 
18604      """ 
18605          flimage_add_text(pImage, text, length, style, size, txtcolr, bgcolr, tran, tx, ty, rot) -> num. 
18606   
18607          @param pImage : pointer to image 
18608      """ 
18609   
18610      _flimage_add_text = cfuncproto( 
18611              load_so_libflimage(), "flimage_add_text", 
18612              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_int, cty.c_int, 
18613              cty.c_int, cty.c_uint, cty.c_uint, cty.c_int, cty.c_double, 
18614              cty.c_double, cty.c_int], 
18615              """int flimage_add_text(FL_IMAGE * im, const char * str, int len, 
18616                 int style, int size, unsigned int tcol, unsigned int bcol, 
18617                 int tran, double tx, double ty, int rot) 
18618              """) 
18619      stext = convert_to_string(text) 
18620      ilength = convert_to_int(length) 
18621      istyle = convert_to_int(style) 
18622      isize = convert_to_int(size) 
18623      uitxtcol = convert_to_uint(txtcolr) 
18624      uibgcol = convert_to_uint(bgcolr) 
18625      itran = convert_to_int(tran) 
18626      ftx = convert_to_double(tx) 
18627      fty = convert_to_double(ty) 
18628      irot = convert_to_int(rot) 
18629      keep_elem_refs(pImage, text, length, style, size, txtcolr, bgcolr, tran, \ 
18630                     tx, ty, rot, stext, ilength, istyle, isize, uitxtcolr, \ 
18631                     uibgcolr, itran, ftx, fty, irot) 
18632      retval = _flimage_add_text(pImage, stext, ilength, istyle, isize, uitxtcolr, \ 
18633                                 uibgcolr, itran, ftx, fty, irot) 
18634      return retval 
18635   
18636   
18637 -def flimage_add_text_struct(pImage, pImageText): 
18638      """ 
18639          flimage_add_text_struct(pImage, pImageText) -> num. 
18640   
18641          @param pImage : pointer to image 
18642      """ 
18643   
18644      _flimage_add_text_struct = cfuncproto( 
18645              load_so_libflimage(), "flimage_add_text_struct", 
18646              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_TEXT)], 
18647              """int flimage_add_text_struct(FL_IMAGE * p1, const char * p2) 
18648              """) 
18649      keep_elem_refs(pImage, pImageText) 
18650      retval = _flimage_add_text_struct(pImage, pImageText) 
18651      return retval 
18652   
18653   
18654 -def flimage_delete_all_text(pImage): 
18655      """ 
18656          flimage_delete_all_text(pImage) 
18657   
18658          @param pImage : pointer to image 
18659      """ 
18660   
18661      _flimage_delete_all_text = cfuncproto( 
18662              load_so_libflimage(), "flimage_delete_all_text", 
18663              None, [cty.POINTER(FL_IMAGE)], 
18664              """void flimage_delete_all_text(FL_IMAGE * p1) 
18665              """) 
18666      keep_elem_refs(pImage) 
18667      _flimage_delete_all_text(pImage) 
18668   
18669   
18670 -def flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11): 
18671      """ 
18672          flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 
18673   
18674          @param pImage : pointer to image 
18675      """ 
18676   
18677      _flimage_add_marker = cfuncproto( 
18678              load_so_libflimage(), "flimage_add_marker", 
18679              cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_double, 
18680              cty.c_double, cty.c_double, cty.c_double, cty.c_int, cty.c_int, 
18681              cty.c_int, cty.c_uint, cty.c_uint], 
18682              """int flimage_add_marker(FL_IMAGE * p1, const char * p2, 
18683                 double p3, double p4, double p5, double p6, int p7, 
18684                 int p8, int p9, unsigned int p10, unsigned int p11) 
18685              """) 
18686      stext = convert_to_string(text) 
18687      fp3 = convert_to_double(p3) 
18688      fp4 = convert_to_double(p4) 
18689      fp5 = convert_to_double(p5) 
18690      fp6 = convert_to_double(p6) 
18691      ip7 = convert_to_int(p7) 
18692      ip8 = convert_to_int(p8) 
18693      ip9 = convert_to_int(p9) 
18694      uip10 = convert_to_uint(p10) 
18695      uip11 = convert_to_uint(p11) 
18696      keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 
18697                     stext, fp3, fp4, fp5, fp6, ip7, ip8, ip9, uip10, uip11) 
18698      retval = _flimage_add_marker(pImage, stext, fp3, fp4, fp5, fp6, ip7, 
18699                                   ip8, ip9, uip10, uip11) 
18700      return retval 
18701   
18702   
18703 -def flimage_add_marker_struct(pImage, pImageMarker): 
18704      """ 
18705          flimage_add_marker_struct(pImage, pImageMarker) -> num. 
18706   
18707          @param pImage : pointer to image 
18708      """ 
18709   
18710      _flimage_add_marker_struct = cfuncproto( 
18711              load_so_libflimage(), "flimage_add_marker_struct", 
18712              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_MARKER)], 
18713              """int flimage_add_marker_struct(FL_IMAGE * p1, const char * p2) 
18714              """) 
18715      keep_elem_refs(pImage, pImageMarker) 
18716      retval = _flimage_add_marker_struct(pImage, pImageMarker) 
18717      return retval 
18718   
18719   
18720 -def flimage_define_marker(text1, pImageMarker, text2): 
18721      """ flimage_define_marker(text1, pImageMarker, text2) -> num. 
18722      """ 
18723   
18724      _flimage_define_marker = cfuncproto( 
18725              load_so_libflimage(), "flimage_define_marker", 
18726              cty.c_int, [STRING, cty.POINTER(FLIMAGE_MARKER), STRING], 
18727              """int flimage_define_marker(const char *, void ( * ) 
18728                 (FLIMAGE_MARKER *), const char *) 
18729              """) 
18730      stext1 = convert_to_string(text1) 
18731      stext2 = convert_to_string(text2) 
18732      keep_elem_refs(text1, pImageMarker, text2, stext1, stext2) 
18733      retval = _flimage_define_marker(stext1, pImageMarker, stext2) 
18734      return retval 
18735   
18736   
18737 -def flimage_delete_all_markers(pImage): 
18738      """ 
18739          flimage_delete_all_markers(pImage) 
18740   
18741          @param pImage : pointer to image 
18742      """ 
18743   
18744      _flimage_delete_all_markers = cfuncproto( 
18745              load_so_libflimage(), "flimage_delete_all_markers", 
18746              None, [cty.POINTER(FL_IMAGE)], 
18747              """void flimage_delete_all_markers(FL_IMAGE * p1) 
18748              """) 
18749      keep_elem_refs(pImage) 
18750      _flimage_delete_all_markers(pImage) 
18751   
18752   
18753 -def flimage_render_annotation(pImage, win): 
18754      """ 
18755          flimage_render_annotation(pImage, win) -> num. 
18756   
18757          @param pImage : pointer to image 
18758          @param win : window 
18759      """ 
18760   
18761      _flimage_render_annotation = cfuncproto( 
18762              load_so_libflimage(), "flimage_render_annotation", 
18763              cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW], 
18764              """int flimage_render_annotation(FL_IMAGE * p1, FL_WINDOW p2) 
18765              """) 
18766      ulwin = convert_to_Window(win) 
18767      keep_elem_refs(pImage, win, ulwin) 
18768      retval = _flimage_render_annotation(pImage, ulwin) 
18769      return retval 
18770   
18771   
18772 -def flimage_error(pImage, text): 
18773      """ 
18774          flimage_error(pImage, text) 
18775   
18776          @param pImage : pointer to image 
18777      """ 
18778   
18779      _flimage_error = cfuncproto( 
18780              load_so_libflimage(), "flimage_error", 
18781              None, [cty.POINTER(FL_IMAGE), STRING], 
18782              """void flimage_error(FL_IMAGE * p1, const char * p2) 
18783              """) 
18784      stext = convert_to_Window(text) 
18785      keep_elem_refs(pImage, text, stext) 
18786      _flimage_error(pImage, stext) 
18787   
18788   
18789  # built-in format supports 
18790   
18791 -def flimage_enable_pnm(): 
18792      """ 
18793          flimage_enable_pnm() 
18794      """ 
18795   
18796      _flimage_enable_pnm = cfuncproto( 
18797              load_so_libflimage(), "flimage_enable_pnm", 
18798              None, [], 
18799              """void flimage_enable_pnm() 
18800              """) 
18801      _flimage_enable_pnm() 
18802   
18803   
18804 -def flimage_set_fits_bits(p1): 
18805      """ 
18806          flimage_set_fits_bits(p1) -> num. 
18807      """ 
18808   
18809      _flimage_set_fits_bits = cfuncproto( 
18810              load_so_libflimage(), "flimage_set_fits_bits", 
18811              cty.c_int, [cty.c_int], 
18812              """int flimage_set_fits_bits(int p1) 
18813              """) 
18814      ip1 = convert_to_int(p1) 
18815      keep_elem_refs(p1, ip1) 
18816      retval = _flimage_set_fits_bits(ip1) 
18817      return retval 
18818   
18819   
18820 -def flimage_jpeg_output_options(pImageJpegOption): 
18821      """ 
18822          flimage_jpeg_output_options(pImageJpegOption) 
18823      """ 
18824   
18825      _flimage_jpeg_output_options = cfuncproto( 
18826              load_so_libflimage(), "flimage_jpeg_output_options", 
18827              None, [cty.POINTER(FLIMAGE_JPEG_OPTION)], 
18828              """void flimage_jpeg_output_options(FLIMAGE_JPEG_OPTION * p1) 
18829              """) 
18830      keep_elem_refs(pImageJpegOption) 
18831      _flimage_jpeg_output_options(pImageJpegOption) 
18832   
18833   
18834 -def flimage_pnm_output_options(p1): 
18835      """ 
18836          flimage_pnm_output_options(p1) 
18837      """ 
18838   
18839      _flimage_pnm_output_options = cfuncproto( 
18840              load_so_libflimage(), "flimage_pnm_output_options", 
18841              None, [cty.c_int], 
18842              """void flimage_pnm_output_options(int p1) 
18843              """) 
18844      ip1 = convert_to_int(p1) 
18845      keep_elem_refs(p1, ip1) 
18846      _flimage_pnm_output_options(ip1) 
18847   
18848   
18849 -def flimage_gif_output_options(p1): 
18850      """ 
18851          flimage_gif_output_options(p1) 
18852      """ 
18853   
18854      _flimage_gif_output_options = cfuncproto( 
18855              load_so_libflimage(), "flimage_gif_output_options", 
18856              None, [cty.c_int], 
18857              """void flimage_gif_output_options(int p1) 
18858              """) 
18859      ip1 = convert_to_int(p1) 
18860      keep_elem_refs(p1, ip1) 
18861      _flimage_gif_output_options(ip1) 
18862   
18863   
18864 -def flimage_ps_options(): 
18865      """ 
18866          flimage_ps_options() -> pFlpsControl 
18867      """ 
18868   
18869      _flimage_ps_options = cfuncproto( 
18870              load_so_libflimage(), "flimage_ps_options", 
18871              cty.POINTER(FLPS_CONTROL), [], 
18872              """FLPS_CONTROL * flimage_ps_options() 
18873              """) 
18874      retval = _flimage_ps_options() 
18875      return retval 
18876   
18877   
18878  flimage_jpeg_options = flimage_jpeg_output_options 
18879  flimage_pnm_options = flimage_pnm_output_options 
18880  flimage_gif_options = flimage_gif_output_options 
18881   
18882   
18883 -def flimage_get_number_of_formats(): 
18884      """ 
18885          flimage_get_number_of_formats() -> num. 
18886      """ 
18887   
18888      _flimage_get_number_of_formats = cfuncproto( 
18889              load_so_libflimage(), "flimage_get_number_of_formats", 
18890              cty.c_int, [], 
18891              """int flimage_get_number_of_formats() 
18892              """) 
18893      retval = _flimage_get_number_of_formats() 
18894      return retval 
18895   
18896   
18897 -def flimage_get_format_info(p1): 
18898      """ 
18899          flimage_get_format_info(p1) -> ImageFormatInfo class instance 
18900      """ 
18901   
18902      _flimage_get_format_info = cfuncproto( 
18903              load_so_libflimage(), "flimage_get_format_info", 
18904              cty.POINTER(FLIMAGE_FORMAT_INFO), [cty.c_int], 
18905              """const char * flimage_get_format_info(int p1) 
18906              """) 
18907      ip1 = convert_to_int(p1) 
18908      keep_elem_refs(p1, ip1) 
18909      retval = _flimage_get_format_info(ip1) 
18910      return retval 
18911   
18912   
18913 -def fl_get_matrix(nrows, ncols, esize): 
18914      """ 
18915          fl_get_matrix(nrows, ncols, esize) -> ? 
18916   
18917          @param nrows : number of rows 
18918          @param ncols : number of columns 
18919          @param esize : size of matrix 
18920      """ 
18921   
18922      _fl_get_matrix = cfuncproto( 
18923              load_so_libflimage(), "fl_get_matrix", 
18924              cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint], 
18925              """void * fl_get_matrix(int p1, int p2, unsigned int p3) 
18926              """) 
18927      inrows = convert_to_int(nrows) 
18928      incols = convert_to_int(ncols) 
18929      uiesize = convert_to_uint(esize) 
18930      keep_elem_refs(nrows, ncols, esize, inrows, incols, uiesize) 
18931      retval = _fl_get_matrix(inrows, incols, uiesize) 
18932      return retval 
18933   
18934   
18935 -def fl_make_matrix(nrows, ncols, esize, mem): 
18936      """ 
18937          fl_make_matrix(nrows, ncols, esize, mem) -> ? 
18938   
18939          Makes a matrix out of a given piece of memory. 
18940   
18941          @param nrows : number of rows 
18942          @param ncols : number of columns 
18943          @param esize : size of matrix 
18944          @param mem : memory 
18945      """ 
18946   
18947      _fl_make_matrix = cfuncproto( 
18948              load_so_libflimage(), "fl_make_matrix", 
18949              cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint, cty.c_void_p], 
18950              """void * fl_make_matrix(int p1, int p2, unsigned int p3, 
18951                 void * p4) 
18952              """) 
18953      inrows = convert_to_int(nrows) 
18954      incols = convert_to_int(ncols) 
18955      uiesize = convert_to_uint(esize) 
18956      pmem = cty.cast(mem, cty.c_void_p) 
18957      keep_elem_refs(nrows, ncols, esize, mem, inrows, incols, uiesize, pmem) 
18958      retval = _fl_make_matrix(inrows, incols, uiesize, pmem) 
18959      return retval 
18960   
18961   
18962 -def fl_free_matrix(mtrx): 
18963      """ 
18964          fl_free_matrix(mtrx) 
18965      """ 
18966   
18967      _fl_free_matrix = cfuncproto( 
18968              load_so_libflimage(), "fl_free_matrix", 
18969              None, [cty.c_void_p], 
18970              """void fl_free_matrix(void * p1) 
18971              """) 
18972      pmtrx = cty.cast(mtrx, cty.c_void_p) 
18973      keep_elem_refs(mtrx, pmtrx) 
18974      _fl_free_matrix(pmtrx) 
18975   
18976   
18977  # This function is retained for compatibility reasons only. 
18978  # It returns 1 always. 
18979 -def fl_init_RGBdatabase(text): 
18980      """ 
18981          fl_init_RGBdatabase(text) -> num. 
18982      """ 
18983   
18984      _fl_init_RGBdatabase = cfuncproto( 
18985              load_so_libflimage(), "fl_init_RGBdatabase", 
18986              cty.c_int, [STRING], 
18987              """int fl_init_RGBdatabase(const char * p1) 
18988              """) 
18989      stext = convert_to_string(text) 
18990      keep_elem_refs(text, stext) 
18991      retval = _fl_init_RGBdatabase(stext) 
18992      return retval 
18993   
18994   
18995 -def fl_lookup_RGBcolor(text, p2, p3, p4): 
18996      """ 
18997          fl_lookup_RGBcolor(text, p2, p3, p4) -> num. 
18998      """ 
18999   
19000      _fl_lookup_RGBcolor = cfuncproto( 
19001              load_so_libflimage(), "fl_lookup_RGBcolor", 
19002              cty.c_int, [STRING, cty.POINTER(cty.c_int), \ 
19003              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
19004              """int fl_lookup_RGBcolor(const char * p1, int * p2, 
19005                 int * p3, int * p4) 
19006              """) 
19007      stext = convert_to_string(text) 
19008      keep_elem_refs(text, p2, p3, p4) 
19009      retval = _fl_lookup_RGBcolor(stext, p2, p3, p4) 
19010      return retval 
19011   
19012   
19013  FLIMAGE_Identify = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FILE)) 
19014  FLIMAGE_Description = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
19015  FLIMAGE_Read_Pixels = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
19016  FLIMAGE_Write_Image = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 
19017   
19018 -def flimage_add_format(formalname, shortname, extension, flimagetype, \ 
19019                         py_ImageIdentify, py_ImageDescription, \ 
19020                         py_ImageReadPixels, py_ImageWriteImage): 
19021      """ flimage_add_format(formalname, shortname, extension, flimagetype, 
19022          py_ImageIdentify, py_ImageDescription, py_ImageReadPixels, 
19023          py_ImageWriteImage) -> num. 
19024      """ 
19025   
19026      _flimage_add_format = cfuncproto( 
19027              load_so_libflimage(), "flimage_add_format", 
19028              cty.c_int, [STRING, STRING, STRING, cty.c_int, FLIMAGE_Identify, 
19029              FLIMAGE_Description, FLIMAGE_Read_Pixels, FLIMAGE_Write_Image], 
19030              """int flimage_add_format(const char * p1, const char * p2, 
19031                 const char * p3, int p4, FLIMAGE_Identify p5, 
19032                 FLIMAGE_Description p6, FLIMAGE_Read_Pixels p7, 
19033                 FLIMAGE_Write_Image p8) 
19034              """) 
19035      check_admitted_values(flimagetype, FLIMAGETYPE_list) 
19036      sformalname = convert_to_string(formalname) 
19037      sshortname = convert_to_string(shortname) 
19038      sextension = convert_to_string(extension) 
19039      iflimagetype = convert_to_int(flimagetype) 
19040      c_ImageIdentify = FLIMAGE_Identify(py_ImageIdentify) 
19041      c_ImageDescription = FLIMAGE_Description(py_ImageDescription) 
19042      c_ImageReadPixels = FLIMAGE_Read_Pixels(py_ImageReadPixels) 
19043      c_ImageWriteImage = FLIMAGE_Write_Image(py_ImageWriteImage) 
19044      keep_cfunc_refs(c_ImageIdentify, py_ImageIdentify, c_ImageDescription, \ 
19045                      py_ImageDescription, c_ImageReadPixels, py_ImageReadPixels, 
19046                      c_ImageWriteImage, py_ImageWriteImage) 
19047      keep_elem_refs(formalname, shortname, extension, flimagetype, \ 
19048                     sformalname, sshortname, sextension, iflimagetype) 
19049      retval = _flimage_add_format(sformalname, sshortname, sextension, \ 
19050                      flimagetype, c_ImageIdentify, c_ImageDescription, \ 
19051                      c_ImageReadPixels, c_ImageWriteImage) 
19052      return retval 
19053   
19054   
19055 -def flimage_set_annotation_support(p1, p2): 
19056      """ flimage_set_annotation_support(p1, p2) 
19057      """ 
19058   
19059      _flimage_set_annotation_support = cfuncproto( 
19060              load_so_libflimage(), "flimage_set_annotation_support", 
19061              None, [cty.c_int, cty.c_int], 
19062              """void flimage_set_annotation_support(int p1, int p2) 
19063              """) 
19064      ip1 = convert_to_int(p1) 
19065      ip2 = convert_to_int(p2) 
19066      keep_elem_refs(p1, p2, ip1, ip2) 
19067      _flimage_set_annotation_support(ip1, ip2) 
19068   
19069   
19070 -def flimage_getcolormap(pImage): 
19071      """ 
19072          flimage_getcolormap(pImage) -> num. 
19073   
19074          @param pImage : pointer to image 
19075      """ 
19076   
19077      _flimage_getcolormap = cfuncproto( 
19078              load_so_libflimage(), "flimage_getcolormap", 
19079              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19080              """int flimage_getcolormap(FL_IMAGE * p1) 
19081              """) 
19082      keep_elem_refs(pImage) 
19083      retval = _flimage_getcolormap(pImage) 
19084      return retval 
19085   
19086   
19087 -def fl_select_mediancut_quantizer(): 
19088      """ 
19089          fl_select_mediancut_quantizer() 
19090      """ 
19091   
19092      _fl_select_mediancut_quantizer = cfuncproto( 
19093              load_so_libflimage(), "fl_select_mediancut_quantizer", 
19094              None, [], 
19095              """void fl_select_mediancut_quantizer() 
19096              """) 
19097      _fl_select_mediancut_quantizer() 
19098   
19099   
19100  # simple image processing routines 
19101   
19102 -def flimage_convolve(pImage, p2, p3, p4): 
19103      """ 
19104          flimage_convolve(pImage, p2, p3, p4) -> num. 
19105   
19106          @param pImage : pointer to image 
19107      """ 
19108   
19109      _flimage_convolve = cfuncproto( 
19110              load_so_libflimage(), "flimage_convolve", 
19111              cty.c_int, [cty.POINTER(FL_IMAGE), 
19112              cty.POINTER(cty.POINTER(cty.c_int)), cty.c_int, cty.c_int], 
19113              """int flimage_convolve(FL_IMAGE * p1, int * * p2, int p3, 
19114                 int p4) 
19115              """) 
19116      ip3 = convert_to_int(p3) 
19117      ip4 = convert_to_int(p4) 
19118      keep_elem_refs(pImage, p2, p3, p4, ip3, ip4) 
19119      retval = _flimage_convolve(pImage, p2, ip3, ip4) 
19120      return retval 
19121   
19122   
19123 -def flimage_convolvea(pImage, p2, p3, p4): 
19124      """ 
19125          flimage_convolvea(pImage, p2, p3, p4) -> num. 
19126   
19127          @param pImage : pointer to image 
19128      """ 
19129   
19130      _flimage_convolvea = cfuncproto( 
19131              load_so_libflimage(), "flimage_convolvea", 
19132              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 
19133              cty.c_int, cty.c_int], 
19134              """int flimage_convolvea(FL_IMAGE * p1, int * p2, int p3, int p4) 
19135              """) 
19136      keep_elem_refs(pImage, p2, p3, p4) 
19137      retval = _flimage_convolvea(pImage, p2, p3, p4) 
19138      return retval 
19139   
19140   
19141 -def flimage_tint(pImage, p2, p3): 
19142      """ 
19143          flimage_tint(pImage, p2, p3) -> num. 
19144   
19145          @param pImage : pointer to image 
19146      """ 
19147   
19148      _flimage_tint = cfuncproto( 
19149              load_so_libflimage(), "flimage_tint", 
19150              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_double], 
19151              """int flimage_tint(FL_IMAGE * p1, unsigned int p2, double p3) 
19152              """) 
19153      keep_elem_refs(pImage, p2, p3) 
19154      retval = _flimage_tint(pImage, p2, p3) 
19155      return retval 
19156   
19157   
19158 -def flimage_rotate(pImage, p2, p3): 
19159      """ 
19160          flimage_rotate(pImage, p2, p3) -> num. 
19161   
19162          @param pImage : pointer to image 
19163      """ 
19164   
19165      _flimage_rotate = cfuncproto( 
19166              load_so_libflimage(), "flimage_rotate", 
19167              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
19168              """int flimage_rotate(FL_IMAGE * p1, int p2, int p3) 
19169              """) 
19170      ip2 = convert_to_int(p2) 
19171      ip3 = convert_to_int(p3) 
19172      keep_elem_refs(pImage, p2, p3, ip2, ip3) 
19173      retval = _flimage_rotate(pImage, ip2, ip3) 
19174      return retval 
19175   
19176   
19177 -def flimage_flip(pImage, p2): 
19178      """ 
19179          flimage_flip(pImage, p2) -> num. 
19180   
19181          @param pImage : pointer to image 
19182      """ 
19183   
19184      _flimage_flip = cfuncproto( 
19185              load_so_libflimage(), "flimage_flip", 
19186              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 
19187              """int flimage_flip(FL_IMAGE * p1, int p2) 
19188              """) 
19189      ip2 = convert_to_int(p2) 
19190      keep_elem_refs(pImage, p2, ip2) 
19191      retval = _flimage_flip(pImage, ip2) 
19192      return retval 
19193   
19194   
19195 -def flimage_scale(pImage, p2, p3, p4): 
19196      """ 
19197          flimage_scale(pImage, p2, p3, p4) -> num. 
19198   
19199          @param pImage : pointer to image 
19200      """ 
19201   
19202      _flimage_scale = cfuncproto( 
19203              load_so_libflimage(), "flimage_scale", 
19204              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19205              cty.c_int], 
19206              """int flimage_scale(FL_IMAGE * p1, int p2, int p3, int p4) 
19207              """) 
19208      ip2 = convert_to_int(p2) 
19209      ip3 = convert_to_int(p3) 
19210      ip4 = convert_to_int(p4) 
19211      keep_elem_refs(pImage, p2, p3, p4, ip2, ip3, ip4) 
19212      retval = _flimage_scale(pImage, ip2, ip3, ip4) 
19213      return retval 
19214   
19215   
19216 -def flimage_warp(pImage, p2, p3, p4, p5): 
19217      """ 
19218          flimage_warp(pImage, p2, p3, p4, p5) -> num. 
19219   
19220          @param pImage : pointer to image 
19221      """ 
19222   
19223      _flimage_warp = cfuncproto( 
19224              load_so_libflimage(), "flimage_warp", 
19225              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_float * 2), 
19226              cty.c_int, cty.c_int, cty.c_int], 
19227              """int flimage_warp(FL_IMAGE * p1, float * p2, int p3, int p4, 
19228                 int p5) 
19229              """) 
19230      ip3 = convert_to_int(p3) 
19231      ip4 = convert_to_int(p4) 
19232      ip5 = convert_to_int(p5) 
19233      keep_elem_refs(pImage, p2, p3, p4, p5, ip3, ip4, ip5) 
19234      retval = _flimage_warp(pImage, p2, ip3, ip4, ip5) 
19235      return retval 
19236   
19237   
19238 -def flimage_autocrop(pImage, p2): 
19239      """ 
19240          flimage_autocrop(pImage, p2) -> num. 
19241   
19242          @param pImage : pointer to image 
19243      """ 
19244   
19245      _flimage_autocrop = cfuncproto( 
19246              load_so_libflimage(), "flimage_autocrop", 
19247              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 
19248              """int flimage_autocrop(FL_IMAGE * p1, unsigned int p2) 
19249              """) 
19250      uip2 = convert_to_uint(p2) 
19251      keep_elem_refs(pImage, p2, uip2) 
19252      retval = _flimage_autocrop(pImage, uip2) 
19253      return retval 
19254   
19255   
19256  #def flimage_get_autocrop(pImage, bk, xl, yt, xr, yb)       *API change* 
19257 -def flimage_get_autocrop(pImage, bk): 
19258      """ flimage_get_autocrop(pImage, bk) -> num., xl, yt, xr, yb 
19259   
19260          @param pImage : pointer to image 
19261      """ 
19262   
19263      _flimage_get_autocrop = cfuncproto( 
19264              load_so_libflimage(), "flimage_get_autocrop", 
19265              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, 
19266              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19267              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
19268              """int flimage_get_autocrop(FL_IMAGE * p1, unsigned int p2, 
19269                 int * p3, int * p4, int * p5, int * p6) 
19270              """) 
19271      uibk = convert_to_uint(bk) 
19272      xl, pxl = make_int_and_pointer() 
19273      yt, pyt = make_int_and_pointer() 
19274      xr, pxr = make_int_and_pointer() 
19275      yb, pyb = make_int_and_pointer() 
19276      keep_elem_refs(pImage, bk, uibk, xl, pxl, yt, pyt, xr, pxr, yb, pyb) 
19277      retval = _flimage_get_autocrop(pImage, uibk, pxl, pyt, pxr, pyb) 
19278      return retval, xl, yt, xr, yb 
19279   
19280   
19281 -def flimage_crop(pImage, p2, p3, p4, p5): 
19282      """ 
19283          flimage_crop(pImage, p2, p3, p4, p5) -> num. 
19284   
19285          @param pImage : pointer to image 
19286      """ 
19287   
19288      _flimage_crop = cfuncproto( 
19289              load_so_libflimage(), "flimage_crop", 
19290              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19291              cty.c_int, cty.c_int], 
19292              """int flimage_crop(FL_IMAGE * p1, int p2, int p3, 
19293                 int p4, int p5) 
19294              """) 
19295      ip2 = convert_to_int(p2) 
19296      ip3 = convert_to_int(p3) 
19297      ip4 = convert_to_int(p4) 
19298      ip5 = convert_to_int(p5) 
19299      keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4, ip5) 
19300      retval = _flimage_crop(pImage, ip2, ip3, ip4, ip5) 
19301      return retval 
19302   
19303   
19304 -def flimage_replace_pixel(pImage, p2, p3): 
19305      """ 
19306          flimage_replace_pixel(pImage, p2, p3) -> num. 
19307   
19308          @param pImage : pointer to image 
19309      """ 
19310   
19311      _flimage_replace_pixel = cfuncproto( 
19312              load_so_libflimage(), "flimage_replace_pixel", 
19313              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_uint], 
19314              """int flimage_replace_pixel(FL_IMAGE * p1, unsigned int p2, 
19315                 unsigned int p3) 
19316              """) 
19317      uip2 = convert_to_uint(p2) 
19318      uip3 = convert_to_uint(p3) 
19319      keep_elem_refs(pImage, p2, p3, uip2, uip3) 
19320      retval = _flimage_replace_pixel(pImage, uip2, uip3) 
19321      return retval 
19322   
19323   
19324 -def flimage_transform_pixels(pImage, red, green, blue): 
19325      """ 
19326          flimage_transform_pixels(pImage, red, green, blue) -> num. 
19327   
19328          @param pImage : pointer to image 
19329      """ 
19330   
19331      _flimage_transform_pixels = cfuncproto( 
19332              load_so_libflimage(), "flimage_transform_pixels", 
19333              cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 
19334              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 
19335              """int flimage_transform_pixels(FL_IMAGE * p1, int * p2, 
19336                 int * p3, int * p4) 
19337              """) 
19338      pred = cty.cast(red, cty.POINTER(cty.c_int)) 
19339      pgreen = cty.cast(green, cty.POINTER(cty.c_int)) 
19340      pblue = cty.cast(blue, cty.POINTER(cty.c_int)) 
19341      keep_elem_refs(pImage, red, green, blue, pred, pgreen, pblue) 
19342      retval = _flimage_transform_pixels(pImage, pred, pgreen, pblue) 
19343      return retval 
19344   
19345   
19346 -def flimage_windowlevel(pImage, p2, p3): 
19347      """ 
19348          flimage_windowlevel(pImage, p2, p3) -> num. 
19349   
19350          @param pImage : pointer to image 
19351      """ 
19352   
19353      _flimage_windowlevel = cfuncproto( 
19354              load_so_libflimage(), "flimage_windowlevel", 
19355              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 
19356              """int flimage_windowlevel(FL_IMAGE * p1, int p2, int p3) 
19357              """) 
19358      ip2 = convert_to_int(p2) 
19359      ip3 = convert_to_int(p3) 
19360      keep_elem_refs(pImage, p2, p3, ip2, ip3) 
19361      retval = _flimage_windowlevel(pImage, ip2, ip3) 
19362      return retval 
19363   
19364   
19365 -def flimage_enhance(pImage, p2): 
19366      """ 
19367          flimage_enhance(pImage, p2) -> num. 
19368   
19369          @param pImage : pointer to image 
19370      """ 
19371   
19372      _flimage_enhance = cfuncproto( 
19373              load_so_libflimage(), "flimage_enhance", 
19374              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 
19375              """int flimage_enhance(FL_IMAGE * p1, int p2) 
19376              """) 
19377      ip2 = convert_to_int(p2) 
19378      keep_elem_refs(pImage, p2, ip2) 
19379      retval = _flimage_enhance(pImage, ip2) 
19380      return retval 
19381   
19382   
19383 -def flimage_from_pixmap(pImage, pixmap): 
19384      """ 
19385          flimage_from_pixmap(pImage, pixmap) -> num. 
19386   
19387          @param pImage : pointer to image 
19388          @param pixmap : pixmap value 
19389      """ 
19390   
19391      _flimage_from_pixmap = cfuncproto( 
19392              load_so_libflimage(), "flimage_from_pixmap", 
19393              cty.c_int, [cty.POINTER(FL_IMAGE), Pixmap], 
19394              """int flimage_from_pixmap(FL_IMAGE * p1, Pixmap p2) 
19395              """) 
19396      ulpixmap = convert_to_Pixmap(pixmap) 
19397      keep_elem_refs(pImage, pixmap, ulpixmap) 
19398      retval = _flimage_from_pixmap(pImage, ulpixmap) 
19399      return retval 
19400   
19401   
19402 -def flimage_to_pixmap(pImage, win): 
19403      """ 
19404          flimage_to_pixmap(pImage, win) -> pixmap 
19405   
19406          @param pImage : pointer to image 
19407          @param win : window id 
19408      """ 
19409   
19410      _flimage_to_pixmap = cfuncproto( 
19411              load_so_libflimage(), "flimage_to_pixmap", 
19412              Pixmap, [cty.POINTER(FL_IMAGE), FL_WINDOW], 
19413              """Pixmap flimage_to_pixmap(FL_IMAGE * p1, FL_WINDOW p2) 
19414              """) 
19415      ulwin = convert_to_Window(win) 
19416      keep_elem_refs(pImage, win, ulwin) 
19417      retval = _flimage_to_pixmap(pImage, ulwin) 
19418      return retval 
19419   
19420   
19421 -def flimage_dup(pImage): 
19422      """ flimage_dup(pImage) -> pImage 
19423   
19424          @param pImage : pointer to image 
19425      """ 
19426   
19427      _flimage_dup = cfuncproto( 
19428              load_so_libflimage(), "flimage_dup", 
19429              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 
19430              """FL_IMAGE * flimage_dup(FL_IMAGE * p1) 
19431              """) 
19432      keep_elem_refs(pImage) 
19433      retval = _flimage_dup(pImage) 
19434      return retval 
19435   
19436   
19437  # Miscellaneous prototypes 
19438   
19439 -def fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize): 
19440      """ fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize) -> ? 
19441      """ 
19442   
19443      _fl_get_submatrix = cfuncproto( 
19444              load_so_libflimage(), "fl_get_submatrix", 
19445              cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 
19446              cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 
19447              """void * fl_get_submatrix(void * p1, int p2, int p3, int p4, 
19448                 int p5, int p6, int p7, unsigned int p8) 
19449              """) 
19450      pinmtrx = cty.cast(inmtrx, cty.c_void_p) 
19451      irows = convert_to_int(rows) 
19452      icols = convert_to_int(cols) 
19453      ir1 = convert_to_int(r1) 
19454      ic1 = convert_to_int(c1) 
19455      irs = convert_to_int(rs) 
19456      ics = convert_to_int(cs) 
19457      uiesize = convert_to_uint(esize) 
19458      keep_elem_refs(inmtrx, rows, cols, r1, c1, rs, cs, esize, pinmtrx, \ 
19459                     irows, icols, ir1, ic1, irs, ics, uiesize) 
19460      retval = _fl_get_submatrix(pinmtrx, irows, icols, ir1, ic1, irs, ics, \ 
19461                                 uiesize) 
19462      return retval 
19463   
19464   
19465 -def fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage): 
19466      """ fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage) -> num. 
19467      """ 
19468   
19469      _fl_j2pass_quantize_packed = cfuncproto( 
19470              load_so_libflimage(), "fl_j2pass_quantize_packed", 
19471              cty.c_int, [cty.POINTER(cty.POINTER(cty.c_uint)), cty.c_int, 
19472              cty.c_int, cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 
19473              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19474              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19475              cty.POINTER(FL_IMAGE)], 
19476              """int fl_j2pass_quantize_packed(unsigned int * * p1, int p2, 
19477                 int p3, int p4, short unsigned int * * p5, int * p6, 
19478                 int * p7, int * p8, int * p9, FL_IMAGE * p10) 
19479              """) 
19480      ip2 = convert_to_int(p2) 
19481      ip3 = convert_to_int(p3) 
19482      ip4 = convert_to_int(p4) 
19483      keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage, ip2, ip3, ip4) 
19484      retval = _fl_j2pass_quantize_packed(p1, ip2, ip3, ip4, p5, p6, p7, p8, \ 
19485                                          p9, pImage) 
19486      return retval 
19487   
19488   
19489 -def fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage): 
19490      """ fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage) -> num. 
19491      """ 
19492   
19493      _fl_j2pass_quantize_rgb = cfuncproto( 
19494              load_so_libflimage(), "fl_j2pass_quantize_rgb", 
19495              cty.c_int, [cty.POINTER(cty.POINTER(cty.c_ubyte)), 
19496              cty.POINTER(cty.POINTER(cty.c_ubyte)), 
19497              cty.POINTER(cty.POINTER(cty.c_ubyte)), cty.c_int, cty.c_int, 
19498              cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 
19499              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19500              cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 
19501              cty.POINTER(FL_IMAGE)], 
19502              """int fl_j2pass_quantize_rgb(unsigned char * * p1, 
19503                 unsigned char * * p2, unsigned char * * p3, int p4, int p5, 
19504                 int p6, short unsigned int * * p7, int * p8, int * p9, 
19505                 int * p10, int * p11, FL_IMAGE * p12) 
19506              """) 
19507      ip4 = convert_to_int(p4) 
19508      ip5 = convert_to_int(p5) 
19509      ip6 = convert_to_int(p6) 
19510      keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage, 
19511                     ip4, ip5, ip6) 
19512      retval = _fl_j2pass_quantize_rgb(p1, p2, p3, ip4, ip5, ip6, p7, p8, p9, \ 
19513                                       p10, p11, pImage) 
19514      return retval 
19515   
19516   
19517 -def fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize): 
19518      """ fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize) -> ? 
19519      """ 
19520   
19521      _fl_make_submatrix = cfuncproto( 
19522              load_so_libflimage(), "fl_make_submatrix", 
19523              cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 
19524              cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 
19525              """void * fl_make_submatrix(void * p1, int p2, int p3, int p4, 
19526                 int p5, int p6, int p7, unsigned int p8) 
19527              """) 
19528      irows = convert_to_int(rows) 
19529      icols = convert_to_int(cols) 
19530      ir1 = convert_to_int(r1) 
19531      ic1 = convert_to_int(c1) 
19532      irs = convert_to_int(rs) 
19533      ics = convert_to_int(cs) 
19534      uiesize = convert_to_uint(esize) 
19535      keep_elem_refs(in_, rows, cols, r1, c1, rs, cs, esize, irows, icols, \ 
19536                 ir1, ic1, irs, ics, uiesize) 
19537      retval = _fl_make_submatrix(in_, irows, icols, ir1, ic1, irs, ics, \ 
19538                                  uiesize) 
19539      return retval 
19540   
19541   
19542 -def fl_pack_bits(p1, p2, p3): 
19543      """ fl_pack_bits(p1, p2, p3) 
19544      """ 
19545   
19546      _fl_pack_bits = cfuncproto( 
19547              load_so_libflimage(), "fl_pack_bits", 
19548              None, [cty.POINTER(cty.c_ubyte), cty.POINTER(cty.c_ushort), 
19549              cty.c_int], 
19550              """void fl_pack_bits(unsigned char * p1, short unsigned int * p2, 
19551                 int p3) 
19552              """) 
19553      ip3 = convert_to_int(p3) 
19554      keep_elem_refs(p1, p2, p3, ip3) 
19555      _fl_pack_bits(p1, p2, ip3) 
19556   
19557   
19558 -def fl_unpack_bits(p1, p2, p3): 
19559      """ fl_unpack_bits(p1, p2, p3) 
19560      """ 
19561   
19562      _fl_unpack_bits = cfuncproto( 
19563              load_so_libflimage(), "fl_unpack_bits", 
19564              None, [cty.POINTER(cty.c_ushort), cty.POINTER(cty.c_ubyte), 
19565              cty.c_int], 
19566              """void fl_unpack_bits(short unsigned int * p1, 
19567                 unsigned char * p2, int p3) 
19568              """) 
19569      ip3 = convert_to_int(p3) 
19570      keep_elem_refs(p1, p2, p3, ip3) 
19571      _fl_unpack_bits(p1, p2, ip3) 
19572   
19573   
19574 -def fl_value_to_bits(val): 
19575      """ 
19576          fl_value_to_bits(val) -> num. 
19577           
19578          @param val : value to convert to bits 
19579      """ 
19580   
19581      _fl_value_to_bits = cfuncproto( 
19582              load_so_libflimage(), "fl_value_to_bits", 
19583              cty.c_uint, [cty.c_uint], 
19584              """unsigned int fl_value_to_bits(unsigned int p1) 
19585              """) 
19586      uival = convert_to_uint(val) 
19587      keep_elem_refs(val, uival) 
19588      retval = _fl_value_to_bits(uival) 
19589      return retval 
19590   
19591   
19592 -def flimage_add_comments(pImage, p2, p3): 
19593      """ 
19594          flimage_add_comments(pImage, p2, p3) 
19595   
19596          @param pImage : pointer to image 
19597      """ 
19598   
19599      _flimage_add_comments = cfuncproto( 
19600              load_so_libflimage(), "flimage_add_comments", 
19601              None, [cty.POINTER(FL_IMAGE), STRING, cty.c_int], 
19602              """void flimage_add_comments(FL_IMAGE * p1, const char * p2, 
19603                 int p3) 
19604              """) 
19605      sp2 = convert_to_string(p2) 
19606      ip3 = convert_to_int(p3) 
19607      keep_elem_refs(pImage, p2, p3, sp2, ip3) 
19608      _flimage_add_comments(pImage, sp2, ip3) 
19609   
19610   
19611 -def flimage_color_to_pixel(pImage, p2, p3, p4, p5): 
19612      """ 
19613          flimage_color_to_pixel(pImage, p2, p3, p4, p5) -> num. 
19614   
19615          @param pImage : pointer to image 
19616      """ 
19617   
19618      _flimage_color_to_pixel = cfuncproto( 
19619              load_so_libflimage(), "flimage_color_to_pixel", 
19620              cty.c_ulong, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 
19621              cty.c_int, cty.POINTER(cty.c_int)], 
19622              """)long unsigned int flimage_color_to_pixel(FL_IMAGE * p1, 
19623                 int p2, int p3, int p4, int * p5) 
19624              """) 
19625      ip2 = convert_to_int(p2) 
19626      ip3 = convert_to_int(p3) 
19627      ip4 = convert_to_int(p4) 
19628      keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4) 
19629      retval = _flimage_color_to_pixel(pImage, ip2, ip3, ip4, p5) 
19630      return retval 
19631   
19632   
19633 -def flimage_combine(pImage1, pImage2, alpha): 
19634      """ flimage_combine(pImage1, pImage2, alpha) -> pImage 
19635   
19636          @param pImage1 : pointer to first image to combine 
19637          @param pImage2 : pointer to second image to combine 
19638          @param alpha : alpha level? 
19639      """ 
19640   
19641      _flimage_combine = cfuncproto( 
19642              load_so_libflimage(), "flimage_combine", 
19643              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), 
19644              cty.POINTER(FL_IMAGE), cty.c_double], 
19645              """FL_IMAGE * flimage_combine(FL_IMAGE * p1, FL_IMAGE * p2, 
19646                 double p3) 
19647              """) 
19648      falpha = convert_to_double(alpha) 
19649      keep_elem_refs(pImage1, pImage2, alpha, falpha) 
19650      retval = _flimage_combine(pImage1, pImage2, falpha) 
19651      return retval 
19652   
19653   
19654 -def flimage_display_markers(pImage): 
19655      """ 
19656          flimage_display_markers(pImage) 
19657   
19658          @param pImage : pointer to image 
19659      """ 
19660   
19661      _flimage_display_markers = cfuncproto( 
19662              load_so_libflimage(), "flimage_display_markers", 
19663              None, [cty.POINTER(FL_IMAGE)], 
19664              """void flimage_display_markers(FL_IMAGE * p1) 
19665              """) 
19666      keep_elem_refs(pImage) 
19667      _flimage_display_markers(pImage) 
19668   
19669   
19670 -def flimage_dup_(pImage, p2): 
19671      """ 
19672          flimage_dup_(pImage, p2) -> pImage 
19673   
19674          @param pImage : pointer to image 
19675      """ 
19676   
19677      _flimage_dup_ = cfuncproto( 
19678              load_so_libflimage(), "flimage_dup_", 
19679              cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), cty.c_int], 
19680              """FL_IMAGE * flimage_dup_(FL_IMAGE * p1, int p2) 
19681              """) 
19682      ip2 = convert_to_int(p2) 
19683      keep_elem_refs(pImage, p2, ip2) 
19684      retval = _flimage_dup_(pImage, ip2) 
19685      return retval 
19686   
19687   
19688 -def flimage_enable_bmp(): 
19689      """ 
19690          flimage_enable_bmp() 
19691      """ 
19692   
19693      _flimage_enable_bmp = cfuncproto( 
19694              load_so_libflimage(), "flimage_enable_bmp", 
19695              None, [], 
19696              """void flimage_enable_bmp() 
19697              """) 
19698      _flimage_enable_bmp() 
19699   
19700   
19701 -def flimage_enable_fits(): 
19702      """ 
19703          flimage_enable_fits() 
19704      """ 
19705   
19706      _flimage_enable_fits = cfuncproto( 
19707              load_so_libflimage(), "flimage_enable_fits", 
19708              None, [], 
19709              """void flimage_enable_fits() 
19710              """) 
19711      _flimage_enable_fits() 
19712   
19713   
19714 -def flimage_enable_genesis(): 
19715      """ 
19716          flimage_enable_genesis() 
19717      """ 
19718   
19719      _flimage_enable_genesis = cfuncproto( 
19720              load_so_libflimage(), "flimage_enable_genesis", 
19721              None, [], 
19722              """void flimage_enable_genesis() 
19723              """) 
19724      _flimage_enable_genesis() 
19725   
19726   
19727 -def flimage_enable_gif(): 
19728      """ 
19729          flimage_enable_gif() 
19730      """ 
19731   
19732      _flimage_enable_gif = cfuncproto( 
19733              load_so_libflimage(), "flimage_enable_gif", 
19734              None, [], 
19735              """void flimage_enable_gif() 
19736              """) 
19737      _flimage_enable_gif() 
19738   
19739   
19740 -def flimage_enable_gzip(): 
19741      """ 
19742          flimage_enable_gzip() 
19743      """ 
19744   
19745      _flimage_enable_gzip = cfuncproto( 
19746              load_so_libflimage(), "flimage_enable_gzip", 
19747              None, [], 
19748              """void flimage_enable_gzip() 
19749              """) 
19750      _flimage_enable_gzip() 
19751   
19752   
19753 -def flimage_enable_jpeg(): 
19754      """ 
19755          flimage_enable_jpeg() 
19756      """ 
19757   
19758      _flimage_enable_jpeg = cfuncproto( 
19759              load_so_libflimage(), "flimage_enable_jpeg", 
19760              None, [], 
19761              """void flimage_enable_jpeg() 
19762              """) 
19763      _flimage_enable_jpeg() 
19764   
19765   
19766 -def flimage_enable_png(): 
19767      """ 
19768          flimage_enable_png() 
19769      """ 
19770   
19771      _flimage_enable_png = cfuncproto( 
19772              load_so_libflimage(), "flimage_enable_png", 
19773              None, [], 
19774              """void flimage_enable_png() 
19775              """) 
19776      _flimage_enable_png() 
19777   
19778   
19779 -def flimage_enable_ps(): 
19780      """ 
19781          flimage_enable_ps() 
19782      """ 
19783   
19784      _flimage_enable_ps = cfuncproto( 
19785              load_so_libflimage(), "flimage_enable_ps", 
19786              None, [], 
19787              """void flimage_enable_ps() 
19788              """) 
19789      _flimage_enable_ps() 
19790   
19791   
19792 -def flimage_enable_sgi(): 
19793      """ 
19794          flimage_enable_sgi() 
19795      """ 
19796   
19797      _flimage_enable_sgi = cfuncproto( 
19798              load_so_libflimage(), "flimage_enable_sgi", 
19799              None, [], 
19800              """void flimage_enable_sgi() 
19801              """) 
19802      _flimage_enable_sgi() 
19803   
19804   
19805 -def flimage_enable_tiff(): 
19806      """ 
19807          flimage_enable_tiff() 
19808      """ 
19809   
19810      _flimage_enable_tiff = cfuncproto( 
19811              load_so_libflimage(), "flimage_enable_tiff", 
19812              None, [], 
19813              """void flimage_enable_tiff() 
19814              """) 
19815      _flimage_enable_tiff() 
19816   
19817   
19818 -def flimage_enable_xbm(): 
19819      """ 
19820          flimage_enable_xbm() 
19821      """ 
19822   
19823      _flimage_enable_xbm = cfuncproto( 
19824              load_so_libflimage(), "flimage_enable_xbm", 
19825              None, [], 
19826              """void flimage_enable_xbm() 
19827              """) 
19828      _flimage_enable_xbm() 
19829   
19830   
19831 -def flimage_enable_xpm(): 
19832      """ 
19833          flimage_enable_xpm() 
19834      """ 
19835   
19836      _flimage_enable_xpm = cfuncproto( 
19837              load_so_libflimage(), "flimage_enable_xpm", 
19838              None, [], 
19839              """void flimage_enable_xpm() 
19840              """) 
19841      _flimage_enable_xpm() 
19842   
19843   
19844 -def flimage_enable_xwd(): 
19845      """ 
19846          flimage_enable_xwd() 
19847      """ 
19848   
19849      _flimage_enable_xwd = cfuncproto( 
19850              load_so_libflimage(), "flimage_enable_xwd", 
19851              None, [], 
19852              """void flimage_enable_xwd() 
19853              """) 
19854      _flimage_enable_xwd() 
19855   
19856   
19857 -def flimage_free_ci(pImage): 
19858      """ 
19859          flimage_free_ci(pImage) 
19860   
19861          @param pImage : pointer to image 
19862      """ 
19863   
19864      _flimage_free_ci = cfuncproto( 
19865              load_so_libflimage(), "flimage_free_ci", 
19866              None, [cty.POINTER(FL_IMAGE)], 
19867              """void flimage_free_ci(FL_IMAGE * p1) 
19868              """) 
19869      keep_elem_refs(pImage) 
19870      _flimage_free_ci(pImage) 
19871   
19872   
19873 -def flimage_free_gray(pImage): 
19874      """ 
19875          flimage_free_gray(pImage) 
19876   
19877          @param pImage : pointer to image 
19878      """ 
19879   
19880      _flimage_free_gray = cfuncproto( 
19881              load_so_libflimage(), "flimage_free_gray", 
19882              None, [cty.POINTER(FL_IMAGE)], 
19883              """void flimage_free_gray(FL_IMAGE * p1) 
19884              """) 
19885      keep_elem_refs(pImage) 
19886      _flimage_free_gray(pImage) 
19887   
19888   
19889 -def flimage_free_linearlut(pImage): 
19890      """ 
19891          flimage_free_linearlut(pImage) 
19892   
19893          @param pImage : pointer to image 
19894      """ 
19895   
19896      _flimage_free_linearlut = cfuncproto( 
19897              load_so_libflimage(), "flimage_free_linearlut", 
19898              None, [cty.POINTER(FL_IMAGE)], 
19899              """void flimage_free_linearlut(FL_IMAGE * p1) 
19900              """) 
19901      keep_elem_refs(pImage) 
19902      _flimage_free_linearlut(pImage) 
19903   
19904   
19905 -def flimage_free_rgb(pImage): 
19906      """ 
19907          flimage_free_rgb(pImage) 
19908   
19909          @param pImage : pointer to image 
19910      """ 
19911   
19912      _flimage_free_rgb = cfuncproto( 
19913              load_so_libflimage(), "flimage_free_rgb", 
19914              None, [cty.POINTER(FL_IMAGE)], 
19915              """void flimage_free_rgb(FL_IMAGE * p1) 
19916              """) 
19917      keep_elem_refs(pImage) 
19918      _flimage_free_rgb(pImage) 
19919   
19920   
19921 -def flimage_freemem(pImage): 
19922      """ 
19923          flimage_freemem(pImage) 
19924   
19925          @param pImage : pointer to image 
19926      """ 
19927   
19928      _flimage_freemem = cfuncproto( 
19929              load_so_libflimage(), "flimage_freemem", 
19930              None, [cty.POINTER(FL_IMAGE)], 
19931              """void flimage_freemem(FL_IMAGE * p1) 
19932              """) 
19933      keep_elem_refs(pImage) 
19934      _flimage_freemem(pImage) 
19935   
19936   
19937 -def flimage_get_closest_color_from_map(pImage, p2): 
19938      """ 
19939          flimage_get_closest_color_from_map(pImage, p2) -> num. 
19940   
19941          @param pImage : pointer to image 
19942      """ 
19943   
19944      _flimage_get_closest_color_from_map = cfuncproto( 
19945              load_so_libflimage(), "flimage_get_closest_color_from_map", 
19946              cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 
19947              """int flimage_get_closest_color_from_map(FL_IMAGE * p1, 
19948                 unsigned int p2) 
19949              """) 
19950      uip2 = convert_to_uint(p2) 
19951      keep_elem_refs(pImage, p2, uip2) 
19952      retval = _flimage_get_closest_color_from_map(pImage, uip2) 
19953      return retval 
19954   
19955   
19956 -def flimage_get_linearlut(pImage): 
19957      """ 
19958          flimage_get_linearlut(pImage) -> num. 
19959   
19960          @param pImage : pointer to image 
19961      """ 
19962   
19963      _flimage_get_linearlut = cfuncproto( 
19964              load_so_libflimage(), "flimage_get_linearlut", 
19965              cty.c_int, [cty.POINTER(FL_IMAGE)], 
19966              """int flimage_get_linearlut(FL_IMAGE * p1) 
19967              """) 
19968      keep_elem_refs(pImage) 
19969      retval = _flimage_get_linearlut(pImage) 
19970      return retval 
19971   
19972   
19973 -def flimage_invalidate_pixels(pImage): 
19974      """ 
19975          flimage_invalidate_pixels(pImage) 
19976   
19977          @param pImage : pointer to image 
19978      """ 
19979   
19980      _flimage_invalidate_pixels = cfuncproto( 
19981              load_so_libflimage(), "flimage_invalidate_pixels", 
19982              None, [cty.POINTER(FL_IMAGE)], 
19983              """void flimage_invalidate_pixels(FL_IMAGE * p1) 
19984              """) 
19985      keep_elem_refs(pImage) 
19986      _flimage_invalidate_pixels(pImage) 
19987   
19988   
19989 -def flimage_open(filename): 
19990      """ 
19991          flimage_open(filename) -> pImage 
19992   
19993          @param filename : name of file to open 
19994      """ 
19995   
19996      _flimage_open = cfuncproto( 
19997              load_so_libflimage(), "flimage_open", 
19998              cty.POINTER(FL_IMAGE), [STRING], 
19999              """FL_IMAGE * flimage_open(const char * p1) 
20000              """) 
20001      sfilename = convert_to_string(filename) 
20002      keep_elem_refs(filename, sfilename) 
20003      retval = _flimage_open(sfilename) 
20004      return retval 
20005   
20006   
20007 -def flimage_read_annotation(pImage): 
20008      """ 
20009          flimage_read_annotation(pImage) -> num. 
20010   
20011          @param pImage : pointer to image 
20012      """ 
20013   
20014      _flimage_read_annotation = cfuncproto( 
20015              load_so_libflimage(), "flimage_read_annotation", 
20016              cty.c_int, [cty.POINTER(FL_IMAGE)], 
20017              """int flimage_read_annotation(FL_IMAGE * p1) 
20018              """) 
20019      keep_elem_refs(pImage) 
20020      retval = _flimage_read_annotation(pImage) 
20021      return retval 
20022   
20023   
20024 -def flimage_replace_image(pImage, w, h, r, g, b): 
20025      """ 
20026          flimage_replace_image(pImage, w, h, r, g, b) 
20027   
20028          @param pImage : pointer to image 
20029      """ 
20030   
20031      _flimage_replace_image = cfuncproto( 
20032              load_so_libflimage(), "flimage_replace_image", 
20033              None, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, cty.c_void_p, 
20034              cty.c_void_p, cty.c_void_p], 
20035              """void flimage_replace_image(FL_IMAGE * p1, int p2, int p3, 
20036                 void * p4, void * p5, void * p6) 
20037              """) 
20038      iw = convert_to_int(w) 
20039      ih = convert_to_int(h) 
20040      pr = cty.cast(r, cty.c_void_p) 
20041      pg = cty.cast(g, cty.c_void_p) 
20042      pb = cty.cast(b, cty.c_void_p) 
20043      keep_elem_refs(pImage, w, h, r, g, b, iw, ih, pr, pg, pb) 
20044      _flimage_replace_image(pImage, iw, ih, pr, pg, pb) 
20045   
20046   
20047 -def flimage_swapbuffer(pImage): 
20048      """ 
20049          flimage_swapbuffer(pImage) -> num. 
20050   
20051          @param pImage : pointer to image 
20052      """ 
20053   
20054      _flimage_swapbuffer = cfuncproto( 
20055              load_so_libflimage(), "flimage_swapbuffer", 
20056              cty.c_int, [cty.POINTER(FL_IMAGE)], 
20057              """int flimage_swapbuffer(FL_IMAGE * p1) 
20058              """) 
20059      keep_elem_refs(pImage) 
20060      retval = _flimage_swapbuffer(pImage) 
20061      return retval 
20062   
20063   
20064 -def flimage_to_ximage(pImage, win, pXWindowAttributes): 
20065      """ 
20066          flimage_to_ximage(pImage, win, pXWindowAttributes) -> num. 
20067   
20068          @param pImage : pointer to image 
20069          @param win : window id 
20070          @param pXWindowAttributes : pointer to XWindowAttributes 
20071             struct 
20072      """ 
20073   
20074      _flimage_to_ximage = cfuncproto( 
20075              load_so_libflimage(), "flimage_to_ximage", 
20076              cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW, 
20077              cty.POINTER(XWindowAttributes)], 
20078              """int flimage_to_ximage(FL_IMAGE * p1, FL_WINDOW p2, 
20079                 XWindowAttributes * p3) 
20080              """) 
20081      ulwin = convert_to_Window(win) 
20082      keep_elem_refs(pImage, win, pXWindowAttributes, ulwin) 
20083      retval = _flimage_to_ximage(pImage, ulwin, pXWindowAttributes) 
20084      return retval 
20085   
20086   
20087 -def flimage_write_annotation(pImage): 
20088      """ 
20089          flimage_write_annotation(pImage) -> num. 
20090   
20091          @param pImage : pointer to image 
20092      """ 
20093   
20094      _flimage_write_annotation = cfuncproto( 
20095              load_so_libflimage(), "flimage_write_annotation", 
20096              cty.c_int, [cty.POINTER(FL_IMAGE)], 
20097              """int flimage_write_annotation(FL_IMAGE * p1) 
20098              """) 
20099      keep_elem_refs(pImage) 
20100      retval = _flimage_write_annotation(pImage) 
20101      return retval 
20102   
20103   
20104 -def flps_apply_gamma(p1): 
20105      """ flps_apply_gamma(p1) 
20106      """ 
20107   
20108      _flps_apply_gamma = cfuncproto( 
20109              load_so_libflimage(), "flps_apply_gamma", 
20110              None, [cty.c_float], 
20111              """void flps_apply_gamma(float p1) 
20112              """) 
20113      fp1 = convert_to_float(p1) 
20114      keep_elem_refs(p1, fp1) 
20115      _flps_apply_gamma(fp1) 
20116   
20117   
20118 -def flps_arc(fill, x, y, r, t1, t2, colr): 
20119      """ flps_arc(p1, p2, p3, p4, p5, p6, p7) 
20120      """ 
20121   
20122      _flps_arc = cfuncproto( 
20123              load_so_libflimage(), "flps_arc", 
20124              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20125              cty.c_int, cty.c_long], 
20126              """void flps_arc(int p1, int p2, int p3, int p4, int p5, int p6, 
20127                 long int p7) 
20128              """) 
20129      ifill = convert_to_int(fill) 
20130      ix = convert_to_int(x) 
20131      iy = convert_to_int(y) 
20132      ir = convert_to_int(r) 
20133      it1 = convert_to_int(t1) 
20134      it2 = convert_to_int(t2) 
20135      lcolr = convert_to_long(colr) 
20136      keep_elem_refs(fill, x, y, r, t1, t2, colr, ifill, ix, iy, ir, it1, \ 
20137                     it2, lcolr) 
20138      _flps_arc(ifill, ix, iy, ir, it1, it2, lcolr) 
20139   
20140   
20141 -def flps_circ(fill, x, y, r, colr): 
20142      """ flps_circ(fill, x, y, r, colr) 
20143      """ 
20144   
20145      _flps_circ = cfuncproto( 
20146              load_so_libflimage(), "flps_circ", 
20147              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 
20148              """void flps_circ(int p1, int p2, int p3, int p4, long int p5) 
20149              """) 
20150      ifill = convert_to_int(fill) 
20151      ix = convert_to_int(x) 
20152      iy = convert_to_int(y) 
20153      ir = convert_to_int(r) 
20154      lcolr = convert_to_long(colr) 
20155      keep_elem_refs(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 
20156      _flps_circ(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 
20157   
20158   
20159 -def flps_color(colr): 
20160      """ flps_color(colr) 
20161      """ 
20162   
20163      _flps_color = cfuncproto( 
20164              load_so_libflimage(), "flps_color", 
20165              None, [cty.c_long], 
20166              """void flps_color(long int p1) 
20167              """) 
20168      lcolr = convert_to_long(colr) 
20169      keep_elem_refs(colr, lcolr) 
20170      _flps_color(lcolr) 
20171   
20172   
20173 -def flps_draw_box(style, x, y, w, h, colr, bwIn): 
20174      """ flps_draw_box(style, x, y, w, h, colr, bwIn) 
20175      """ 
20176   
20177      _flps_draw_box = cfuncproto( 
20178              load_so_libflimage(), "flps_draw_box", 
20179              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20180              cty.c_long, cty.c_int], 
20181              """void flps_draw_box(int p1, int p2, int p3, int p4, int p5, 
20182                 long int p6, int p7) 
20183              """) 
20184      istyle = convert_to_int(style) 
20185      ix = convert_to_int(x) 
20186      iy = convert_to_int(y) 
20187      iw = convert_to_int(w) 
20188      ih = convert_to_int(h) 
20189      lcolr = convert_to_long(colr) 
20190      ibwIn = convert_to_int(bwIn) 
20191      keep_elem_refs(style, x, y, w, h, colr, bwIn, istyle, ix, iy, iw, ih, \ 
20192                     lcolr, ibwIn) 
20193      _flps_draw_box(istyle, ix, iy, iw, ih, lcolr, ibwIn) 
20194   
20195   
20196 -def flps_draw_checkbox(boxtype, x, y, w, h, colr, bw): 
20197      """ flps_draw_checkbox(boxtype, x, y, w, h, colr, bw) 
20198      """ 
20199   
20200      _flps_draw_checkbox = cfuncproto( 
20201              load_so_libflimage(), "flps_draw_checkbox", 
20202              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20203              cty.c_long, cty.c_int], 
20204              """void flps_draw_checkbox(int p1, int p2, int p3, int p4, 
20205                 int p5, long int p6, int p7) 
20206              """) 
20207      iboxtype = convert_to_int(boxtype) 
20208      ix = convert_to_int(x) 
20209      iy = convert_to_int(y) 
20210      iw = convert_to_int(w) 
20211      ih = convert_to_int(h) 
20212      lcolr = convert_to_long(colr) 
20213      ibw = convert_to_int(bw) 
20214      keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, ih, \ 
20215                     lcolr, ibw) 
20216      _flps_draw_checkbox(iboxtype, ix, iy, iw, ih, lcolr, ibw) 
20217   
20218   
20219 -def flps_draw_frame(style, x, y, w, h, colr, bw): 
20220      """ flps_draw_frame(style, x, y, w, h, colr, bw) 
20221      """ 
20222   
20223      _flps_draw_frame = cfuncproto( 
20224              load_so_libflimage(), "flps_draw_frame", 
20225              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20226              cty.c_long, cty.c_int], 
20227              """void flps_draw_frame(int p1, int p2, int p3, int p4, int p5, 
20228                 long int p6, int p7) 
20229              """) 
20230      istyle = convert_to_int(style) 
20231      ix = convert_to_int(x) 
20232      iy = convert_to_int(y) 
20233      iw = convert_to_int(w) 
20234      ih = convert_to_int(h) 
20235      lcolr = convert_to_long(colr) 
20236      ibw = convert_to_int(bw) 
20237      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, \ 
20238                     lcolr, ibw) 
20239      _flps_draw_frame(istyle, ix, iy, iw, ih, lcolr, ibw) 
20240   
20241   
20242 -def flps_draw_symbol(label, x, y, w, h, colr): 
20243      """ flps_draw_symbol(label, x, y, w, h, colr) -> num. 
20244      """ 
20245   
20246      _flps_draw_symbol = cfuncproto( 
20247              load_so_libflimage(), "flps_draw_symbol", 
20248              cty.c_int, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20249              cty.c_long], 
20250              """int flps_draw_symbol(const char * p1, int p2, int p3, int p4, 
20251                 int p5, long int p6) 
20252              """) 
20253      slabel = convert_to_string(label) 
20254      ix = convert_to_int(x) 
20255      iy = convert_to_int(y) 
20256      iw = convert_to_int(w) 
20257      ih = convert_to_int(h) 
20258      lcolr = convert_to_long(colr) 
20259      keep_elem_refs(label, x, y, w, h, colr, slabel, ix, iy, iw, ih, lcolr) 
20260      retval = _flps_draw_symbol(slabel, ix, iy, iw, ih, lcolr) 
20261      return retval 
20262   
20263   
20264 -def flps_draw_tbox(style, x, y, w, h, colr, bw): 
20265      """ flps_draw_tbox(style, x, y, w, h, colr, bw) 
20266      """ 
20267   
20268      _flps_draw_tbox = cfuncproto( 
20269              load_so_libflimage(), "flps_draw_tbox", 
20270              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20271              cty.c_long, cty.c_int], 
20272              """void flps_draw_tbox(int p1, int p2, int p3, int p4, int p5, 
20273                 long int p6, int p7) 
20274              """) 
20275      istyle = convert_to_int(style) 
20276      ix = convert_to_int(x) 
20277      iy = convert_to_int(y) 
20278      iw = convert_to_int(w) 
20279      ih = convert_to_int(h) 
20280      lcolr = convert_to_long(colr) 
20281      ibw = convert_to_int(bw) 
20282      keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, lcolr, ibw) 
20283      _flps_draw_tbox(istyle, ix, iy, iw, ih, lcolr, ibw) 
20284   
20285   
20286 -def flps_draw_text(align, x, y, w, h, colr, style, size, text): 
20287      """ flps_draw_text(align, x, y, w, h, colr, style, size, text) 
20288      """ 
20289   
20290      _flps_draw_text = cfuncproto( 
20291              load_so_libflimage(), "flps_draw_text", 
20292              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20293              cty.c_long, cty.c_int, cty.c_int, STRING], 
20294              """void flps_draw_text(int p1, int p2, int p3, int p4, int p5, 
20295                 long int p6, int p7, int p8, const char * p9) 
20296              """) 
20297      ialign = convert_to_int(align) 
20298      ix = convert_to_int(x) 
20299      iy = convert_to_int(y) 
20300      iw = convert_to_int(w) 
20301      ih = convert_to_int(h) 
20302      lcolr = convert_to_long(colr) 
20303      istyle = convert_to_int(style) 
20304      isize = convert_to_int(size) 
20305      stext = convert_to_string(text) 
20306      keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 
20307                     ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20308      _flps_draw_text(ialign, ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20309   
20310   
20311 -def flps_draw_text_beside(align, x, y, w, h, colr, style, size, text): 
20312      """ flps_draw_text_beside(align, x, y, w, h, colr, style, size, text) 
20313      """ 
20314   
20315      _flps_draw_text_beside = cfuncproto( 
20316              load_so_libflimage(), "flps_draw_text_beside", 
20317              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20318              cty.c_long, cty.c_int, cty.c_int, STRING], 
20319              """void flps_draw_text_beside(int p1, int p2, int p3, int p4, 
20320                 int p5, long int p6, int p7, int p8, const char * p9) 
20321              """) 
20322      ialign = convert_to_int(align) 
20323      ix = convert_to_int(x) 
20324      iy = convert_to_int(y) 
20325      iw = convert_to_int(w) 
20326      ih = convert_to_int(h) 
20327      lcolr = convert_to_long(colr) 
20328      istyle = convert_to_int(style) 
20329      isize = convert_to_int(size) 
20330      stext = convert_to_string(text) 
20331      keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 
20332                     ix, iy, iw, ih, lcolr, istyle, isize, stext) 
20333      _flps_draw_text_beside(ialign, ix, iy, iw, ih, lcolr, istyle, isize, \ 
20334                             stext) 
20335   
20336   
20337 -def flps_emit_header(title, npages, xi, yi, xf, yf): 
20338      """ flps_emit_header(title, npages, xi, yi, xf, yf) 
20339      """ 
20340   
20341      _flps_emit_header = cfuncproto( 
20342              load_so_libflimage(), "flps_emit_header", 
20343              None, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20344              cty.c_int], 
20345              """void flps_emit_header(const char * p1, int p2, int p3, 
20346                 int p4, int p5, int p6) 
20347              """) 
20348      stitle = convert_to_string(title) 
20349      inpages = convert_to_int(npages) 
20350      ixi = convert_to_int(xi) 
20351      iyi = convert_to_int(yi) 
20352      ixf = convert_to_int(xf) 
20353      iyf = convert_to_int(yf) 
20354      keep_elem_refs(title, npages, xi, yi, xf, yf, stitle, inpages, ixi, \ 
20355                     iyi, ixf, iyf) 
20356      _flps_emit_header(stitle, inpages, ixi, iyi, ixf, iyf) 
20357   
20358   
20359 -def flps_emit_prolog(): 
20360      """ flps_emit_prolog() 
20361      """ 
20362   
20363      _flps_emit_prolog = cfuncproto( 
20364              load_so_libflimage(), "flps_emit_prolog", 
20365              None, [], 
20366              """void flps_emit_prolog() 
20367              """) 
20368      _flps_emit_prolog() 
20369   
20370   
20371 -def flps_get_gray255(colr): 
20372      """ flps_get_gray255(colr) -> num. 
20373      """ 
20374   
20375      _flps_get_gray255 = cfuncproto( 
20376              load_so_libflimage(), "flps_get_gray255", 
20377              cty.c_int, [cty.c_long], 
20378              """int flps_get_gray255(long int p1) 
20379              """) 
20380      lcolr = convert_to_long(colr) 
20381      keep_elem_refs(colr, lcolr) 
20382      retval = _flps_get_gray255(lcolr) 
20383      return retval 
20384   
20385   
20386 -def flps_get_linestyle(): 
20387      """ flps_get_linestyle() -> num. 
20388      """ 
20389   
20390      _flps_get_linestyle = cfuncproto( 
20391              load_so_libflimage(), "flps_get_linestyle", 
20392              cty.c_int, [], 
20393              """int flps_get_linestyle() 
20394              """) 
20395      retval = _flps_get_linestyle() 
20396      return retval 
20397   
20398   
20399 -def flps_get_linewidth(): 
20400      """ flps_get_linewidth() -> width num. 
20401      """ 
20402   
20403      _flps_get_linewidth = cfuncproto( 
20404              load_so_libflimage(), "flps_get_linewidth", 
20405              cty.c_int, [], 
20406              """int flps_get_linewidth() 
20407              """) 
20408      retval = _flps_get_linewidth() 
20409      return retval 
20410   
20411   
20412 -def flps_get_namedcolor(colrname): 
20413      """ flps_get_namedcolor(colrname) -> num. 
20414      """ 
20415   
20416      _flps_get_namedcolor = cfuncproto( 
20417              load_so_libflimage(), "flps_get_namedcolor", 
20418              cty.c_int, [STRING], 
20419              """int flps_get_namedcolor(const char * p1) 
20420              """) 
20421      scolrname = convert_to_string(colrname) 
20422      keep_elem_refs(colrname, scolrname) 
20423      retval = _flps_get_namedcolor(scolrname) 
20424      return retval 
20425   
20426   
20427 -def flps_invalidate_color_cache(): 
20428      """ flps_invalidate_color_cache() 
20429      """ 
20430   
20431      _flps_invalidate_color_cache = cfuncproto( 
20432              load_so_libflimage(), "flps_invalidate_color_cache", 
20433              None, [], 
20434              """void flps_invalidate_color_cache() 
20435              """) 
20436      _flps_invalidate_color_cache() 
20437   
20438   
20439 -def flps_invalidate_font_cache(): 
20440      """ flps_invalidate_font_cache() 
20441      """ 
20442   
20443      _flps_invalidate_font_cache = cfuncproto( 
20444              load_so_libflimage(), "flps_invalidate_font_cache", 
20445              None, [], 
20446              """void flps_invalidate_font_cache() 
20447              """) 
20448      _flps_invalidate_font_cache() 
20449   
20450   
20451 -def flps_invalidate_linewidth_cache(): 
20452      """ flps_invalidate_linewidth_cache() 
20453      """ 
20454   
20455      _flps_invalidate_linewidth_cache = cfuncproto( 
20456              load_so_libflimage(), "flps_invalidate_linewidth_cache", 
20457              None, [], 
20458              """void flps_invalidate_linewidth_cache() 
20459              """) 
20460      _flps_invalidate_linewidth_cache() 
20461   
20462   
20463 -def flps_invalidate_symbol_cache(): 
20464      """ flps_invalidate_symbol_cache() 
20465      """ 
20466   
20467      _flps_invalidate_symbol_cache = cfuncproto( 
20468              load_so_libflimage(), "flps_invalidate_symbol_cache", 
20469              None, [], 
20470              """void flps_invalidate_symbol_cache() 
20471              """) 
20472      _flps_invalidate_symbol_cache() 
20473   
20474   
20475 -def flps_line(xi, yi, xf, yf, colr): 
20476      """ flps_line(xi, yi, xf, yf, colr) 
20477      """ 
20478   
20479      _flps_line = cfuncproto( 
20480              load_so_libflimage(), "flps_line", 
20481              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 
20482              """void flps_line(int p1, int p2, int p3, int p4, long int p5) 
20483              """) 
20484      ixi = convert_to_int(xi) 
20485      iyi = convert_to_int(yi) 
20486      ixf = convert_to_int(xf) 
20487      iyf = convert_to_int(yf) 
20488      lcolr = convert_to_long(colr) 
20489      keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, lcolr) 
20490      _flps_line(ixi, iyi, ixf, iyf, lcolr) 
20491   
20492   
20493 -def flps_lines(pPoint, num, colr): 
20494      """ flps_lines(pPoint, num, colr) 
20495   
20496          @param pPoint : pointer to point struct 
20497      """ 
20498   
20499      _flps_lines = cfuncproto( 
20500              load_so_libflimage(), "flps_lines", 
20501              None, [cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 
20502              """void flps_lines(FL_POINT * p1, int p2, long int p3) 
20503              """) 
20504      inum = convert_to_int(num) 
20505      lcolr = convert_to_long(colr) 
20506      keep_elem_refs(pPoint, num, colr, inum, lcolr) 
20507      _flps_lines(pPoint, inum, lcolr) 
20508   
20509   
20510 -def flps_linestyle(linestyle): 
20511      """ flps_linestyle(linestyle) 
20512      """ 
20513   
20514      _flps_linestyle = cfuncproto( 
20515              load_so_libflimage(), "flps_linestyle", 
20516              None, [cty.c_int], 
20517              """void flps_linestyle(int p1) 
20518              """) 
20519      check_admitted_listvalues(linestyle, LINE_list) 
20520      ilinestyle = convert_to_int(linestyle) 
20521      keep_elem_refs(linestyle, ilinestyle) 
20522      _flps_linestyle(ilinestyle) 
20523   
20524   
20525 -def flps_linewidth(linewidth): 
20526      """ flps_linewidth(linewidth) 
20527      """ 
20528   
20529      _flps_linewidth = cfuncproto( 
20530              load_so_libflimage(), "flps_linewidth", 
20531              None, [cty.c_int], 
20532              """void flps_linewidth(int p1) 
20533              """) 
20534      ilinewidth = convert_to_int(linewidth) 
20535      keep_elem_refs(linewidth, ilinewidth) 
20536      _flps_linewidth(ilinewidth) 
20537   
20538   
20539 -def flps_log(text): 
20540      """ flps_log(text) 
20541      """ 
20542   
20543      _flps_log = cfuncproto( 
20544              load_so_libflimage(), "flps_log", 
20545              None, [STRING], 
20546              """void flps_log(const char * p1) 
20547              """) 
20548      stext = convert_to_string(text) 
20549      keep_elem_refs(text, stext) 
20550      _flps_log(stext) 
20551   
20552   
20553 -def flps_output(fmt): 
20554      """ flps_output(fmt) 
20555      """ 
20556   
20557      _flps_output = cfuncproto( 
20558              load_so_libflimage(), "flps_output", 
20559              None, [STRING], 
20560              """void flps_output(const char * p1) 
20561              """) 
20562      sfmt = convert_to_string(fmt) 
20563      keep_elem_refs(fmt, sfmt) 
20564      _flps_output(sfmt) 
20565   
20566   
20567 -def flps_oval(fill, x, y, w, h, colr): 
20568      """ flps_oval(fill, x, y, w, h, colr) 
20569      """ 
20570   
20571      _flps_oval = cfuncproto( 
20572              load_so_libflimage(), "flps_oval", 
20573              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20574              cty.c_long], 
20575              """void flps_oval(int p1, int p2, int p3, int p4, int p5, 
20576                 long int p6) 
20577              """) 
20578      ifill = convert_to_int(fill) 
20579      ix = convert_to_int(x) 
20580      iy = convert_to_int(y) 
20581      iw = convert_to_int(w) 
20582      ih = convert_to_int(h) 
20583      lcolr = convert_to_long(colr) 
20584      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20585      _flps_oval(ifill, ix, iy, iw, ih, lcolr) 
20586   
20587   
20588 -def flps_pieslice(fill, x, y, w, h, t1, t2, colr): 
20589      """ flps_pieslice(fill, x, y, w, h, t1, t2, colr) 
20590      """ 
20591   
20592      _flps_pieslice = cfuncproto( 
20593              load_so_libflimage(), "flps_pieslice", 
20594              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20595              cty.c_int, cty.c_int, cty.c_long], 
20596              """void flps_pieslice(int p1, int p2, int p3, int p4, int p5, 
20597                 int p6, int p7, long int p8) 
20598              """) 
20599      ifill = convert_to_int(fill) 
20600      ix = convert_to_int(x) 
20601      iy = convert_to_int(y) 
20602      iw = convert_to_int(w) 
20603      ih = convert_to_int(h) 
20604      it1 = convert_to_int(t1) 
20605      it2 = convert_to_int(t2) 
20606      lcolr = convert_to_long(colr) 
20607      keep_elem_refs(fill, x, y, w, h, t1, t2, colr, ifill, ix, iy, iw, \ 
20608                     ih, it1, it2, lcolr) 
20609      _flps_pieslice(ifill, ix, iy, iw, ih, it1, it2, lcolr) 
20610   
20611   
20612 -def flps_poly(fill, pPoint, num, colr): 
20613      """ flps_poly(fill, pPoint, num, colr) 
20614      """ 
20615   
20616      _flps_poly = cfuncproto( 
20617              load_so_libflimage(), "flps_poly", 
20618              None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 
20619              """void flps_poly(int p1, FL_POINT * p2, int p3, long int p4) 
20620              """) 
20621      ifill = convert_to_int(fill) 
20622      inum = convert_to_int(num) 
20623      lcolr = convert_to_long(colr) 
20624      keep_elem_refs(fill, pPoint, num, colr, ifill, inum, lcolr) 
20625      _flps_poly(ifill, pPoint, inum, lcolr) 
20626   
20627   
20628 -def flps_rectangle(fill, x, y, w, h, colr): 
20629      """ flps_rectangle(fill, x, y, w, h, colr) 
20630      """ 
20631   
20632      _flps_rectangle = cfuncproto( 
20633              load_so_libflimage(), "flps_rectangle", 
20634              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20635              cty.c_long], 
20636              """void flps_rectangle(int p1, int p2, int p3, int p4, int p5, 
20637                 long int p6) 
20638              """) 
20639      ifill = convert_to_int(fill) 
20640      ix = convert_to_int(x) 
20641      iy = convert_to_int(y) 
20642      iw = convert_to_int(w) 
20643      ih = convert_to_int(h) 
20644      lcolr = convert_to_long(colr) 
20645      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20646      _flps_rectangle(ifill, ix, iy, iw, ih, lcolr) 
20647   
20648   
20649 -def flps_reset_cache(): 
20650      """ flps_reset_cache() 
20651      """ 
20652   
20653      _flps_reset_cache = cfuncproto( 
20654              load_so_libflimage(), "flps_reset_cache", 
20655              None, [], 
20656              """void flps_reset_cache() 
20657              """) 
20658      _flps_reset_cache() 
20659   
20660   
20661 -def flps_reset_linewidth(): 
20662      """ flps_reset_linewidth() 
20663      """ 
20664   
20665      _flps_reset_linewidth = cfuncproto( 
20666              load_so_libflimage(), "flps_reset_linewidth", 
20667              None, [], 
20668              """void flps_reset_linewidth() 
20669              """) 
20670      _flps_reset_linewidth() 
20671   
20672   
20673 -def flps_restore_flps(): 
20674      """ flps_restore_flps() 
20675      """ 
20676   
20677      _flps_restore_flps = cfuncproto( 
20678              load_so_libflimage(), "flps_restore_flps", 
20679              None, [], 
20680              """void flps_restore_flps() 
20681              """) 
20682      _flps_restore_flps() 
20683   
20684   
20685 -def flps_rgbcolor(r, g, b): 
20686      """ flps_rgbcolor(r, g, b) 
20687      """ 
20688   
20689      _flps_rgbcolor = cfuncproto( 
20690              load_so_libflimage(), "flps_rgbcolor", 
20691              None, [cty.c_int, cty.c_int, cty.c_int], 
20692              """void flps_rgbcolor(int p1, int p2, int p3) 
20693              """) 
20694      ir = convert_to_int(r) 
20695      ig = convert_to_int(g) 
20696      ib = convert_to_int(b) 
20697      keep_elem_refs(r, g, b, ir, ig, ib) 
20698      _flps_rgbcolor(ir, ig, ib) 
20699   
20700   
20701 -def flps_roundrectangle(fill, x, y, w, h, colr): 
20702      """ flps_roundrectangle(fill, x, y, w, h, colr) 
20703      """ 
20704   
20705      _flps_roundrectangle = cfuncproto( 
20706              load_so_libflimage(), "flps_roundrectangle", 
20707              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 
20708              cty.c_long], 
20709              """void flps_roundrectangle(int p1, int p2, int p3, int p4, 
20710                 int p5, long int p6) 
20711              """) 
20712      ifill = convert_to_int(fill) 
20713      ix = convert_to_int(x) 
20714      iy = convert_to_int(y) 
20715      iw = convert_to_int(w) 
20716      ih = convert_to_int(h) 
20717      lcolr = convert_to_long(colr) 
20718      keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 
20719      _flps_roundrectangle(ifill, ix, iy, iw, ih, lcolr) 
20720   
20721   
20722 -def flps_set_clipping(x, y, w, h): 
20723      """ flps_set_clipping(x, y, w, h) 
20724      """ 
20725   
20726      _flps_set_clipping = cfuncproto( 
20727              load_so_libflimage(), "flps_set_clipping", 
20728              None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int], 
20729              """void flps_set_clipping(int p1, int p2, int p3, int p4) 
20730              """) 
20731      ix = convert_to_int(x) 
20732      iy = convert_to_int(y) 
20733      iw = convert_to_int(w) 
20734      ih = convert_to_int(h) 
20735      keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 
20736      _flps_set_clipping(ix, iy, iw, ih) 
20737   
20738   
20739 -def flps_set_font(style, size): 
20740      """ flps_set_font(style, size) 
20741      """ 
20742   
20743      _flps_set_font = cfuncproto( 
20744              load_so_libflimage(), "flps_set_font", 
20745              None, [cty.c_int, cty.c_int], 
20746              """void flps_set_font(int p1, int p2) 
20747              """) 
20748      check_admitted_listvalues(style, TEXTSTYLE_list) 
20749      istyle = convert_to_int(style) 
20750      isize = convert_to_int(size) 
20751      keep_elem_refs(style, size, istyle, isize) 
20752      _flps_set_font(istyle, isize) 
20753   
20754   
20755 -def flps_unset_clipping(): 
20756      """ flps_unset_clipping() 
20757      """ 
20758   
20759      _flps_unset_clipping = cfuncproto( 
20760              load_so_libflimage(), "flps_unset_clipping", 
20761              None, [], 
20762              """void flps_unset_clipping() 
20763              """) 
20764      _flps_unset_clipping() 
20765